@@ -1,64 +1,66 @@ | |||
# Change Log for keybrd library | |||
All notable changes to the keybrd project will be documented in this file. | |||
This project adheres to [Semantic Versioning 2.0.0](http://semver.org/). | |||
This project adheres to Semantic Versioning 2.0.0(http://semver.org/). | |||
keybrd version 0.x.x is for initial development. The public API should not be considered stable. | |||
keybrd version 1.0.0 will be released when the public API is stable. | |||
## [Unreleased] | |||
## Unreleased | |||
## 0.5.0 (2016-07-18) | |||
* Enhancements | |||
## [0.3.2] - 2016-06-21 | |||
### Added | |||
config_keybrd.h for size configurations. | |||
RowScanner_SPI-ShiftRegisters for compact split keyboards up to 32 keys per matrix. | |||
LED_PinNumber for controlling indicator lights by pin number. | |||
* Backward incompatible changes | |||
* Rename classes | |||
## [0.3.2] - 2016-06-10 | |||
### Changed | |||
* Changed uC from scanning port arrays to scanning Arduino pins, thereby adding support for: | |||
Arduino boards, Teensy 3, and Teensy LC micro controllers | |||
up to 31x31 matrix capability | |||
* Changed IOE from scanning port arrays to scanning single ports. | |||
* Moved scanner and debouncer into their own classes. | |||
## 0.4.1 (2016-06-21) | |||
* Enhancements | |||
* Add config_keybrd.h for size configurations. | |||
* Add RowScanner_SPI-ShiftRegisters for compact split keyboards up to 32 keys per matrix. | |||
* Add LED_PinNumber for controlling indicator lights by pin number. | |||
### Added | |||
* Row_uC | |||
* Row_IOE | |||
* RowScannerInterface | |||
* RowScanner_PinsArray | |||
* RowScanner_PinsBitwise | |||
* DebouncerInterface | |||
* Debouncer_4Samples | |||
## 0.4.0 (2016-06-10) | |||
* Enhancements | |||
* Add Row_uC | |||
* Add Row_IOE | |||
* Add RowScannerInterface | |||
* Add RowScanner_PinsArray | |||
* Add RowScanner_PinsBitwise | |||
* Add DebouncerInterface | |||
* Add Debouncer_4Samples | |||
### Removed | |||
* Port arrays | |||
* Backward incompatible changes | |||
* Change uC from scanning port arrays to scanning Arduino pins, thereby adding support for: | |||
* Arduino boards, Teensy 3, and Teensy LC micro controllers | |||
* up to 31x31 matrix capability | |||
* Change IOE from scanning port arrays to scanning single ports. | |||
* Move scanner and debouncer into their own classes. | |||
* Remove Port arrays | |||
## [0.3.1] - 2016-06-02 | |||
### Added | |||
* RowBase class | |||
* Row::debounce() | |||
## 0.3.1 (2016-06-02) | |||
* Enhancements | |||
* Add RowBase class | |||
* Add Row::debounce() | |||
## [0.3.0] - 2016-05-09 | |||
### Changed | |||
* Restructured the project directory to conform to Arduino library manager specifications | |||
## 0.3.0 (2016-05-09) | |||
* Enhancements | |||
* Add Tutorials | |||
* Backward incompatible changes | |||
* Restructure the project directory to conform to Arduino library manager specifications | |||
* Moved keybrd_DH library extension (for DodoHand) to its own repository | |||
* Moved sketches to examples directory | |||
* Replaced Key_Layered dependency on LayerManager with LayerState class | |||
### Added | |||
* Tutorials | |||
## [0.2.0] - 2016-02-25 | |||
### Added | |||
* Port classes for micro-controllers and I/O expanders | |||
* DH_2565 sketch with DataHand layout | |||
* Sticky mouse button (SMB) for DataHand layout | |||
* Supporting documentation | |||
* Replace Key_Layered dependency on LayerManager with LayerState class | |||
## [0.1.0] - 2015-02-10 | |||
### Added | |||
* The library runs on Teensy 2.0 microcontroller and MCP23018 I/O expander | |||
* Limited to 8x8 matrix, which is enough for compact or split keyboards | |||
* First draft of supporting documentation | |||
* Example keybrd sketches for single-layer, multi-layer, and DataHand layer schemes | |||
## 0.2.0 (2016-02-25) | |||
* Enhancements | |||
* Add Port classes for micro-controllers and I/O expanders | |||
* Add DH_2565 sketch with DataHand layout | |||
* Add Sticky mouse button (SMB) for DataHand layout | |||
* Add Supporting documentation | |||
## 0.1.0 (2015-02-10) | |||
* Enhancements | |||
* The library runs on Teensy 2.0 microcontroller and MCP23018 I/O expander | |||
* Limited to 8x8 matrix, which is enough for compact or split keyboards | |||
* Add first draft of supporting documentation | |||
* Add example keybrd sketches for single-layer, multi-layer, and DataHand layer schemes |
@@ -2,7 +2,7 @@ keybrd Library Developer's Guide | |||
================================ | |||
This guide if for maintaining and writing new classes for the keybrd library and its extension libraries. | |||
The most common reason for new classes are: | |||
* Port classes for micro controller or I/O expanders | |||
* Port classes for I/O expanders | |||
* custom layer schemes for multi-layer keyboards | |||
* experimental features | |||
@@ -207,8 +207,8 @@ Following the style guide makes it easier for the next programmer to understand | |||
* For class names, see above section "Class naming conventions". | |||
* Member names use camelCase starting with lowercase letter. | |||
* Use constants rather than macros, except for header guards. | |||
* Global const names and static const names use ALL_CAPS_AND_UNDERSCORE. | |||
* Macros use ALL_CAPS_AND_UNDERSCORE and have _MACRO suffix e.g. SAMPLE_COUNT_MACRO | |||
* Global const names and static const names use ALL_CAPS_WITH_UNDERSCORE. | |||
* Macros use ALL_CAPS_WITH_UNDERSCORE and have _MACRO suffix e.g. SAMPLE_COUNT_MACRO | |||
* Header guards have _H suffix e.g. #ifndef FILE_NAME_H | |||
* Pointer names are prefixed with "ptr" e.g. ptrRow = &row; | |||
* Arrays names use the plural of element name e.g. Row* const = ptrsRows { &row0, &row1 }; |
@@ -131,7 +131,7 @@ Compile and load workflow: | |||
you might need to press and release the pushbutton on the Teensy circuit board. | |||
## Example keybrd sketches | |||
Example keybrd sketches are in the [examples](../examples/) directory. | |||
Example keybrd sketches are in the examples and tutorials directories. | |||
Extension libraries have their example sketches similarly located. | |||
The example sketch names use the following conventions. | |||
@@ -143,15 +143,30 @@ where | |||
* **feature** is a distinguishing feature of the keybrd sketch e.g. breadboard, LED, sound, Dvorak | |||
* **version** is the sketch's version number | |||
The first field are mandatory, the remaining fields are optional. | |||
The first field are mandatory, the version optional. | |||
## Diode orientation | |||
The physical martix rows and columns on a keyboard can be in any direction or shape. | |||
[diode](https://en.wikipedia.org/wiki/Diode) orientation is specified in [Matrix.h](https://github.com/wolfv6/keybrd/blob/master/src/Matrix.h) | |||
## Active state and diode orientation | |||
Active state is set in the sketch by static variables STROBE_ON and STROBE_OFF. | |||
The following instructions are for setting active state for a Scanner_uC class. | |||
Scanner_ShiftRegs74HC165 and Scanner_Port classes is similar. | |||
For active low | |||
* Use internal pull-down resistors. | |||
* Orient diodes with cathode (banded end) towards the write pins (row) | |||
* Use these two lines in the sketch: | |||
const bool Scanner_uC::STROBE_ON = LOW; | |||
const bool Scanner_uC::STROBE_OFF = HIGH; | |||
For active high | |||
* Use external 10k pull-down resistors. | |||
* Orient diodes with cathode (banded end) towards the read pins. | |||
* Use these two lines in the sketch: | |||
const bool Scanner_uC::STROBE_ON = HIGH; | |||
const bool Scanner_uC::STROBE_OFF = LOW; | |||
![Diode](https://github.com/wolfv6/keybrd/blob/master/tutorials/images/120px-Diode_pinout_en_fr.svg.png) | |||
Diagram is of typical through-the-hole diode in same alignment as diode symbol. | |||
Diagram is of typical through-the-hole [diode](https://en.wikipedia.org/wiki/Diode) in same alignment as diode symbol. | |||
Cross bar and band depict the cathode. | |||
## Troubleshooting check list |
@@ -1,122 +0,0 @@ | |||
/* test debounce() function. 16/6/1 Passed test for SAMPLE_COUNT 1, 2, and 4. | |||
copied from keybrd/src/Row::debounce() | |||
to run test: | |||
$ g++ debounce_unit_test.cpp | |||
$ ./a.out | |||
*/ | |||
#include <inttypes.h> | |||
#include <iostream> | |||
#define SAMPLE_COUNT 4 //number of consecutive equal bits needed to change a debounced bit | |||
uint8_t samples[SAMPLE_COUNT]; //bitwise, one bit per key, most recent readings | |||
uint8_t samplesIndex = 0; //samples[] current write index | |||
uint8_t previousDebounced = 0; //bitwise, one bit per key | |||
uint8_t debounced; //1 means pressed, 0 means released | |||
uint8_t isFallingEdge; //1 means falling edge | |||
uint8_t isRisingEdge; //1 means rising edge | |||
uint8_t debounce(const uint8_t rowState) | |||
{ | |||
uint8_t debouncedChanged; //bitwise | |||
uint8_t all_1 = ~0; //bitwise | |||
uint8_t all_0 = 0; //bitwise | |||
//delayMicroseconds(DELAY_MICROSECONDS); //delay between Row scans to debounce key | |||
samples[samplesIndex] = rowState; //insert rowState into samples[] ring buffer | |||
if (++samplesIndex >= SAMPLE_COUNT) //if end of ring buffer | |||
{ | |||
samplesIndex = 0; //wrap samplesIndex to beginning of ring buffer | |||
} | |||
for (uint8_t j = 0; j < SAMPLE_COUNT; j++) //traverse the sample[] ring buffer | |||
{ | |||
all_1 &= samples[j]; //1 if all samples are 1 | |||
all_0 |= samples[j]; //0 if all samples are 0 | |||
} | |||
// update newDebounce if all the samples agree with one another | |||
// if all samples=1 then debounced=1 | |||
// elseif all samples=0 then debounced=0 | |||
// else debounced=previousDebounced i.e. no change | |||
debounced = all_1 | (all_0 & previousDebounced); | |||
debouncedChanged = debounced xor previousDebounced; | |||
previousDebounced = debounced; | |||
return debouncedChanged; | |||
} | |||
void pressRelease(const uint8_t debouncedChanged) | |||
{ | |||
//bit=1 if last debounced changed from 1 to 0, else bit=0 | |||
isFallingEdge = debouncedChanged & ~previousDebounced; | |||
//bit=1 if last debounced changed from 0 to 1, else bit=0 | |||
isRisingEdge = debouncedChanged & previousDebounced; | |||
} | |||
int main() | |||
{ | |||
//Test input and output only shows first bit of each byte. | |||
const uint8_t pressed[] = {1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0}; | |||
const uint8_t bouncy[] = {1,0,0,0,0,1,0,0,1,1,1,1,0,1,1,1,1,0,0,0,0}; | |||
const uint8_t expectDebounced[]= {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0}; //SAMPLE_COUNT 4 | |||
const uint8_t SCAN_COUNT = sizeof(bouncy)/sizeof(*bouncy); | |||
uint8_t i; | |||
uint8_t debouncedChanged; //1 means debounced changed | |||
std::cout << "button pressed: "; | |||
for (i=0; i<SCAN_COUNT; i++) | |||
{ | |||
std::cout << (int)pressed[i]; | |||
} | |||
std::cout << std::endl; | |||
std::cout << "bouncy signal: "; | |||
for (i=0; i<SCAN_COUNT; i++) | |||
{ | |||
std::cout << (int)bouncy[i]; | |||
} | |||
std::cout << std::endl; | |||
std::cout << "debounced signal: "; | |||
for (i=0; i<SCAN_COUNT; i++) | |||
{ | |||
debouncedChanged = debounce(bouncy[i]); | |||
//pressRelease(debouncedChanged); | |||
std::cout << (int)debounced; | |||
} | |||
std::cout << std::endl; | |||
std::cout << "expected debounced signal: "; | |||
for (i=0; i<SCAN_COUNT; i++) | |||
{ | |||
std::cout << (int)expectDebounced[i]; | |||
} | |||
std::cout << std::endl; | |||
std::cout << "isFallingEdge: "; | |||
for (i=0; i<SCAN_COUNT; i++) | |||
{ | |||
debouncedChanged = debounce(bouncy[i]); | |||
pressRelease(debouncedChanged); | |||
std::cout << (int)isFallingEdge; | |||
} | |||
std::cout << std::endl; | |||
std::cout << "isRisingEdge: "; | |||
for (i=0; i<SCAN_COUNT; i++) | |||
{ | |||
debouncedChanged = debounce(bouncy[i]); | |||
pressRelease(debouncedChanged); | |||
std::cout << (int)isRisingEdge; | |||
} | |||
std::cout << std::endl; | |||
} | |||
void loop() { } |
@@ -1,112 +0,0 @@ | |||
/* keybrd_mapping_bb.ino | |||
Runs on DodoHand hardware or breadboard, using the left matrix, first two rows and columns. | |||
Uses the same variable naming convention as keybrd_DH. | |||
| Layout | **0** | **1** | | |||
|:------:|-------|-------| | |||
| **0** | a ! | b @ | | |||
| **1** | fn | shift | | |||
*/ | |||
// ################# GLOBAL #################### | |||
// ================ INCLUDES =================== | |||
//Arudino library files | |||
#include <Wire.h> | |||
//keybrd library files | |||
//#include <objects_scancode.h> | |||
#include <Code_Sc.h> | |||
#include <Code_ScS.h> | |||
#include <Code_Shift.h> | |||
#include <LayerState.h> | |||
//#include <Code_LayerLock.h> | |||
#include <Code_LayerHold.h> | |||
#include <Key_LayeredKeysArray.h> | |||
#include <RowPort_AVR_Optic.h> | |||
#include <ColPort_AVR.h> | |||
#include <Row.h> | |||
#include <Matrix.h> | |||
#include <Debug.h> | |||
// ================= DEBUG ===================== | |||
Debug debug; | |||
// =========== SPEED CONFUGURATIONS ============ | |||
const unsigned int Row::DELAY_MICROSECONDS = 1000; | |||
// =============== LEFT PORTS ================== | |||
RowPort_AVR_Optic rowPortF_L(DDRF, PORTF); | |||
ColPort_AVR colPortB_L(DDRB, PORTB, PINB, 1<<0 | 1<<1 ); | |||
ColPort* const ptrsColPorts_L[] = { &colPortB_L }; | |||
const uint8_t COL_PORT_L_COUNT = sizeof(ptrsColPorts_L)/sizeof(*ptrsColPorts_L); | |||
// ================= CODES ===================== | |||
// -------------- LAYER CODES ------------------ | |||
LayerState layerState; | |||
//Code_LayerLock l_alpha(0, layerState); | |||
Code_LayerHold l_fn(1, layerState); | |||
// --------------- SHIFT CODE ------------------ | |||
Code_Shift s_shift(MODIFIERKEY_LEFT_SHIFT); | |||
Code_Shift *const ptrsShift[] = { &s_shift }; | |||
Code_Shift *const *const Code_AutoShift::ptrsShifts = ptrsShift; | |||
const uint8_t Code_AutoShift::shiftCount = sizeof(ptrsShifts)/sizeof(*ptrsShifts); | |||
// --------------- SCAN CODES ------------------ | |||
Code_Sc s_a(KEY_A); | |||
Code_Sc s_b(KEY_B); | |||
Code_ScS s_exclamation(KEY_1); | |||
Code_ScS s_at(KEY_2); | |||
LayerStateInterface& Key_LayeredKeysArray::refLayerState = layerState; | |||
// ============== LEFT MATRIX ================== | |||
// --------------- LEFT KEYS ------------------- | |||
Key* const ptrsCodes_L00[] = { &s_a, &s_exclamation }; | |||
Key_LayeredKeysArray k_L00(ptrsCodes_L00); | |||
Key* const ptrsCodes_L01[] = { &s_b, &s_at }; | |||
Key_LayeredKeysArray k_L01(ptrsCodes_L01); | |||
// -------------- LEFT MAPPING ----------------- | |||
// the mapping layout array consumes no additional SRAM | |||
/* | |||
Key* const ptrsLayout[2][2] = { { &k_L00, &k_L01 }, | |||
{ &l_fn, &s_shift } }; | |||
*/ | |||
Key* const ptrsLayout[2][2] = { { &k_L01, &k_L00 }, //swapped keys a-b | |||
{ &l_fn, &s_shift } }; | |||
// --------------- LEFT ROWS ------------------- | |||
Key* const ptrsKeys_L0[] = { ptrsLayout[0][0], ptrsLayout[0][1] }; | |||
Row row_L0(rowPortF_L, 1<<0, ptrsColPorts_L, COL_PORT_L_COUNT, ptrsKeys_L0); | |||
Key* const ptrsKeys_L1[] = { ptrsLayout[1][0], ptrsLayout[1][1] }; | |||
Row row_L1(rowPortF_L, 1<<1, ptrsColPorts_L, COL_PORT_L_COUNT, ptrsKeys_L1); | |||
// -------------- LEFT MATRIX ------------------ | |||
RowBase* const ptrsRows_L[] = { &row_L0, &row_L1 }; | |||
const uint8_t ROW_L_COUNT = sizeof(ptrsRows_L)/sizeof(*ptrsRows_L); | |||
Matrix matrix_L(ptrsRows_L, ROW_L_COUNT, 1); | |||
// ################## MAIN ##################### | |||
void setup() | |||
{ | |||
Keyboard.begin(); | |||
delay(1000); //time for OS to detect USB before printing | |||
Keyboard.print(F("keybrd_mapping_bb.ino, ")); | |||
debug.print_free_RAM(); | |||
} | |||
void loop() | |||
{ | |||
matrix_L.scan(); | |||
} |
@@ -105,41 +105,36 @@ Row_uC row_L1(1, readPins, READ_PIN_COUNT, ptrsKeys_L1); | |||
// ================= RIGHT ROWS ================ | |||
//typedef should be large in /home/wolfv/Documents/Arduino/keybrd_proj/keybrd/src/config_keybrd.h | |||
//Row_ShiftRegisters(STROBE_PIN, READ_PIN_COUNT, ptrsKeys[]) | |||
//Row_ShiftRegisters(strobePin, readPinCount, ptrsKeys[]) | |||
//the s_z are place holders and should not print | |||
/* | |||
//prints 0 1 | |||
Key* ptrsKeys_R0[] = { &s_0, &s_z, &s_z, &s_z, &s_1, &s_z, &s_z, &s_z }; | |||
uint8_t READ_PIN_COUNT_R0 = sizeof(ptrsKeys_R0)/sizeof(*ptrsKeys_R0); | |||
Row_ShiftRegisters row_R0(8, READ_PIN_COUNT_R0, ptrsKeys_R0); | |||
Row_ShiftRegisters row_R0(8, sizeof(ptrsKeys_R0)/sizeof(*ptrsKeys_R0), ptrsKeys_R0); | |||
//prints a b | |||
Key* ptrsKeys_R1[] = { &s_a, &s_z, &s_z, &s_z, &s_b, &s_z, &s_z, &s_z }; | |||
uint8_t READ_PIN_COUNT_R1 = sizeof(ptrsKeys_R1)/sizeof(*ptrsKeys_R1); | |||
Row_ShiftRegisters row_R1(9, READ_PIN_COUNT_R1, ptrsKeys_R1); | |||
Row_ShiftRegisters row_R1(9, sizeof(ptrsKeys_R1)/sizeof(*ptrsKeys_R1), ptrsKeys_R1); | |||
*/ | |||
/* | |||
//prints 0 1 2 | |||
Key* ptrsKeys_R0[] = { &s_0, &s_z, &s_z, &s_z, &s_1, &s_z, &s_z, &s_z, | |||
&s_2, &s_z, &s_z, &s_z }; | |||
uint8_t READ_PIN_COUNT_R0 = sizeof(ptrsKeys_R0)/sizeof(*ptrsKeys_R0); | |||
Row_ShiftRegisters row_R0(8, READ_PIN_COUNT_R0, ptrsKeys_R0); | |||
Row_ShiftRegisters row_R0(8, sizeof(ptrsKeys_R0)/sizeof(*ptrsKeys_R0), ptrsKeys_R0); | |||
*/ | |||
/* | |||
//prints 0 1 2 3 | |||
Key* ptrsKeys_R0[] = { &s_0, &s_z, &s_z, &s_z, &s_1, &s_z, &s_z, &s_z, | |||
&s_2, &s_z, &s_z, &s_z, &s_3, &s_z, &s_z, &s_z }; | |||
uint8_t READ_PIN_COUNT_R0 = sizeof(ptrsKeys_R0)/sizeof(*ptrsKeys_R0); | |||
Row_ShiftRegisters row_R0(8, READ_PIN_COUNT_R0, ptrsKeys_R0); | |||
Row_ShiftRegisters row_R0(8, sizeof(ptrsKeys_R0)/sizeof(*ptrsKeys_R0), ptrsKeys_R0); | |||
*/ | |||
/* | |||
//prints 0 1 2 3 4 5 | |||
Key* ptrsKeys_R0[] = { &s_0, &s_z, &s_z, &s_z, &s_1, &s_z, &s_z, &s_z, | |||
&s_2, &s_z, &s_z, &s_z, &s_3, &s_z, &s_z, &s_z, | |||
&s_4, &s_z, &s_z, &s_z, &s_5, &s_z, &s_z, &s_z }; | |||
uint8_t READ_PIN_COUNT_R0 = sizeof(ptrsKeys_R0)/sizeof(*ptrsKeys_R0); | |||
Row_ShiftRegisters row_R0(8, READ_PIN_COUNT_R0, ptrsKeys_R0); | |||
Row_ShiftRegisters row_R0(8, sizeof(ptrsKeys_R0)/sizeof(*ptrsKeys_R0), ptrsKeys_R0); | |||
*/ | |||
//prints 0 1 2 3 3 4 5 6, microseconds_per_scan=87 with SAMPLE_COUNT 4 | |||
@@ -147,16 +142,14 @@ Key* ptrsKeys_R0[] = { &s_0, &s_z, &s_z, &s_z, &s_1, &s_z, &s_z, &s_z, | |||
&s_2, &s_z, &s_z, &s_z, &s_3, &s_z, &s_z, &s_z, | |||
&s_4, &s_z, &s_z, &s_z, &s_5, &s_z, &s_z, &s_z, | |||
&s_6, &s_z, &s_z, &s_z, &s_3, &s_4, &s_5, &s_6 }; | |||
uint8_t READ_PIN_COUNT_R0 = sizeof(ptrsKeys_R0)/sizeof(*ptrsKeys_R0); | |||
Row_ShiftRegisters row_R0(0, READ_PIN_COUNT_R0, ptrsKeys_R0); | |||
Row_ShiftRegisters row_R0(0, sizeof(ptrsKeys_R0)/sizeof(*ptrsKeys_R0), ptrsKeys_R0); | |||
//prints a b c d u v w x | |||
Key* ptrsKeys_R1[] = { &s_a, &s_z, &s_z, &s_z, &s_b, &s_z, &s_z, &s_z, | |||
&s_c, &s_z, &s_z, &s_z, &s_d, &s_z, &s_z, &s_z, | |||
&s_e, &s_z, &s_z, &s_z, &s_f, &s_z, &s_z, &s_z, | |||
&s_g, &s_z, &s_z, &s_z, &s_u, &s_v, &s_w, &s_x }; | |||
uint8_t READ_PIN_COUNT_R1 = sizeof(ptrsKeys_R1)/sizeof(*ptrsKeys_R1); | |||
Row_ShiftRegisters row_R1(1, READ_PIN_COUNT_R1, ptrsKeys_R1); | |||
Row_ShiftRegisters row_R1(1, sizeof(ptrsKeys_R1)/sizeof(*ptrsKeys_R1), ptrsKeys_R1); | |||
// ################### MAIN #################### | |||
void setup() |
@@ -1,13 +0,0 @@ | |||
#include "Code_Sc_LED.h" | |||
void Code_Sc_LED::press() | |||
{ | |||
Keyboard.press(scancode); | |||
refLED.on(); | |||
} | |||
void Code_Sc_LED::release() | |||
{ | |||
Keyboard.release(scancode); | |||
refLED.off(); | |||
} |
@@ -1,21 +0,0 @@ | |||
#ifndef CODE_SC_LED_H | |||
#define CODE_SC_LED_H | |||
#include <Arduino.h> | |||
#include <inttypes.h> | |||
#include <Code.h> | |||
#include <LED.h> | |||
/* Class Code_Sc_LED sends a scancode when press() or release() is called. | |||
"S" stands for Scancode. | |||
*/ | |||
class Code_Sc_LED : public Code | |||
{ | |||
private: | |||
const uint16_t scancode; | |||
LED& refLED; | |||
public: | |||
Code_Sc_LED(const uint16_t scancode, LED& refLED): scancode(scancode), refLED(refLED) { } | |||
virtual void press(); | |||
virtual void release(); | |||
}; | |||
#endif |
@@ -1 +0,0 @@ | |||
../classes |
@@ -1,109 +0,0 @@ | |||
/* this works on Teensy LC 1*bb, active low and active high | |||
MCP23018 is not working, MCP23018::begin() hangs, details in setup() | |||
| Layout | **0** | **1** | | |||
|:------:|-------|-------| | |||
| **0** | a | b | | |||
| **1** | c | d | | |||
*/ | |||
// ################## GLOBAL ################### | |||
// ================= INCLUDES ================== | |||
#include <Debug.h> | |||
//LEDs | |||
#include <LED_PinNumber.h> | |||
#include "classes/Code_Sc_LED.h" //symlink: ln -s ../classes classes | |||
//IOE Ports | |||
#include "IOExpanderPort.h" | |||
#include <RowPort_MCP23018.h> | |||
#include <ColPort_MCP23018.h> | |||
//Codes | |||
#include <Code_Sc.h> | |||
//Matrix | |||
#include <Row_uC.h> | |||
#include <SPI.h> | |||
#include <Row_ShiftRegisters.h> | |||
// =============== CONFIGURATION =============== | |||
const unsigned int RowBase::DELAY_MICROSECONDS = 500; | |||
//activeLow has diode cathode (band) on row | |||
//activeHigh has diode cathode (band) on col, and pull down resistors on cols | |||
//0=active low, 1= active high | |||
const bool RowScanner_PinsArray::activeHigh = 0; | |||
Debug debug; | |||
// ================= LEFT PINS ================= | |||
uint8_t readPins[] = {14, 15}; | |||
uint8_t READ_PIN_COUNT = sizeof(readPins)/sizeof(*readPins); | |||
LED_PinNumber LED1(16); //Teensy LC pins 16, 17 are 20 mA | |||
// =================== CODES =================== | |||
Code_Sc s_a(KEY_A); | |||
Code_Sc s_b(KEY_B); | |||
Code_Sc s_c(KEY_C); | |||
Code_Sc_LED s_d(KEY_D, LED1); | |||
Code_Sc s_0(KEY_0); | |||
Code_Sc s_1(KEY_1); | |||
Code_Sc s_2(KEY_2); | |||
Code_Sc s_3(KEY_3); | |||
Code_Sc s_4(KEY_4); | |||
Code_Sc s_5(KEY_5); | |||
Code_Sc s_6(KEY_6); | |||
Code_Sc s_7(KEY_7); | |||
Code_Sc s_z(KEY_Z); | |||
// ================= LEFT ROWS ================= | |||
Key* ptrsKeys_L0[] = { &s_a, &s_b }; | |||
Row_uC row_L0(0, readPins, READ_PIN_COUNT, ptrsKeys_L0); | |||
Key* ptrsKeys_L1[] = { &s_c, &s_d }; | |||
Row_uC row_L1(1, readPins, READ_PIN_COUNT, ptrsKeys_L1); | |||
// ================= RIGHT ROWS ================ | |||
/* | |||
Key* ptrsKeys_R[] = { &s_0, &s_z, &s_z, &s_z, | |||
&s_4, &s_z, &s_z, &s_z, | |||
&s_8, &s_z, &s_z, &s_z }; //the s_z are place holders and should not print | |||
*/ | |||
Key* ptrsKeys_R[] = { &s_0, &s_1, &s_2, &s_3, | |||
&s_4, &s_5, &s_6, &s_7 }; //the most that 8-bit send() can handle | |||
const uint8_t KEY_COUNT = sizeof(ptrsKeys_R)/sizeof(*ptrsKeys_R); | |||
//Row_ShiftRegisters row_R(9, 2, ptrsKeys_R, KEY_COUNT); | |||
Row_ShiftRegisters row_R(9, 1, ptrsKeys_R, KEY_COUNT); // (SS, BYTE_COUNT,,) | |||
// ################### MAIN #################### | |||
void setup() | |||
{ | |||
Keyboard.begin(); | |||
SPI.begin(); | |||
row_R.begin(); | |||
//delay(1000); //time for OS to detect USB before printing | |||
Keyboard.print(F("activeState.ino ")); | |||
debug.print_free_RAM(); | |||
} | |||
//uint16_t next = 0; | |||
//elapsedMillis elapsed; | |||
void loop() | |||
{ | |||
row_L0.process(); | |||
row_L1.process(); | |||
row_R.process(); | |||
//row_R0.process(); | |||
//row_R1.process(); | |||
//delay(100); | |||
//Keyboard.println(""); | |||
} |
@@ -1 +0,0 @@ | |||
../classes |
@@ -1,113 +0,0 @@ | |||
/* this works on DH 4*bb, top-left buttons | |||
demo RowScanner_PinsBitwise | |||
| Left | **0** | **1** | | Right | **0** | **1** | | |||
|:-----:|-------|-------| |:-----:|-------|-------| | |||
| **0** | a | b | | **0** | 0 | 1 | | |||
| **1** | c | d | | **1** | 2 | 3 | | |||
*/ | |||
// ################## GLOBAL ################### | |||
// ================= INCLUDES ================== | |||
#include <Debug.h> | |||
//Ports | |||
#include <RowPort_AVR_Optic.h> | |||
#include <ColPort_AVR.h> | |||
//LEDs | |||
#include <LED_AVR.h> | |||
#include <LED_PCA9655E.h> | |||
#include "classes/Code_Sc_LED.h" //symlink: ln -s ../classes classes | |||
//Codes | |||
#include <Code_Sc.h> | |||
//Matrix | |||
#include <Row_IOE.h> | |||
#include <Matrix.h> | |||
// =============== CONFIGURATION =============== | |||
const unsigned int RowBase::DELAY_MICROSECONDS = 500; | |||
const bool RowScanner_PinsBitwise::activeHigh = 1; | |||
Debug debug; | |||
// ================ LEFT PORTS ================= | |||
RowPort_AVR_Optic rowPort_L(DDRF, PORTF); | |||
ColPort_AVR colPort_L(DDRB, PORTB, PINB, 1<<0 | 1<<1 ); | |||
//LED | |||
LED_AVR LED_L1(PORTB, 1<<6); //green | |||
// ================ RIGHT PORTS ================ | |||
#include <IOExpanderPort.h> | |||
#include <RowPort_PCA9655E.h> | |||
#include <ColPort_PCA9655E.h> | |||
const uint8_t IOExpanderPort::ADDR = 0x18; | |||
//row port | |||
IOExpanderPort port1(1, 0); | |||
RowPort_PCA9655E rowPort_R(port1); | |||
//column and pin numbers on schematic_switch_matrix.png and schematic_pca9655_pin_assignments.png | |||
//col port | |||
IOExpanderPort port0(0, 0); | |||
ColPort_PCA9655E colPort_R(port0, 1<<0 | 1<<1 ); | |||
//LED | |||
LED_PCA9655E LED_R1(port1, 1<<5); //blue | |||
// =================== CODES =================== | |||
Code_Sc s_a(KEY_A); | |||
Code_Sc s_b(KEY_B); | |||
Code_Sc s_c(KEY_C); | |||
//Code_Sc s_d(KEY_D); | |||
Code_Sc_LED s_d(KEY_D, LED_L1); | |||
Code_Sc s_0(KEY_0); | |||
Code_Sc s_1(KEY_1); | |||
Code_Sc s_2(KEY_2); | |||
//Code_Sc s_3(KEY_3); | |||
Code_Sc_LED s_3(KEY_3, LED_R1); | |||
// ================= LEFT ROWS ================= | |||
Key* const ptrsKeys_L0[] = { &s_a, &s_b }; | |||
Row_IOE row_L0(rowPort_L, 1<<0, colPort_L, ptrsKeys_L0); //strobe F0 | |||
Key* const ptrsKeys_L1[] = { &s_c, &s_d }; | |||
Row_IOE row_L1(rowPort_L, 1<<1, colPort_L, ptrsKeys_L1); //strobe F1 | |||
// ================= RIGHT ROWS ================ | |||
Key* ptrsKeys_R0[] = { &s_0, &s_1 }; | |||
Row_IOE row_R0(rowPort_R, 1<<0, colPort_R, ptrsKeys_R0); | |||
Key* ptrsKeys_R1[] = { &s_2, &s_3 }; | |||
Row_IOE row_R1(rowPort_R, 1<<1, colPort_R, ptrsKeys_R1); | |||
// ################### MAIN #################### | |||
void setup() | |||
{ | |||
Keyboard.begin(); | |||
Wire.begin(); | |||
delay(1000); //time for OS to detect USB before printing | |||
Keyboard.print(F("activeState_AVR.ino ")); | |||
debug.print_free_RAM(); | |||
rowPort_R.begin(); | |||
colPort_R.begin(); | |||
} | |||
void loop() | |||
{ | |||
row_L0.process(); | |||
row_L1.process(); | |||
row_R0.process(); | |||
row_R1.process(); | |||
//delay(500); | |||
//Keyboard.println(F("")); | |||
} |
@@ -12,22 +12,22 @@ This class was tested on split keyboard with a 3-meter long telephone wire to I/ | |||
Dr. Marty's debounce algorithm: | |||
Periodically read samples and update the state when a number consecutive sample bits are equal. | |||
Output from keybrd/examples/debounce_unit_test.cpp with SAMPLE_COUNT 4: | |||
Output from keybrd/examples/debounce_unit_test.cpp with SAMPLE_COUNT_MACRO 4: | |||
button pressed: 100000001111111110000 | |||
bouncy signal: 100001001111011110000 | |||
debounced signal: 000000000001111111110 | |||
isFallingEdge: 000000000000000000001 | |||
isRisingEdge: 000000000001000000000 | |||
There is a latency equal to SAMPLE_COUNT, between button press and debounced signal. | |||
There is a latency equal to SAMPLE_COUNT_MACRO, between button press and debounced signal. | |||
samples[SAMPLE_COUNT] is a ring buffer. samplesIndex is it's current write index. | |||
SAMPLE_COUNT is the number of consecutive equal samples needed to debounce. | |||
SAMPLE_COUNT is a macro because it defines samples[SAMPLE_COUNT] array size at compile time. | |||
SAMPLE_COUNT is defined in config_keybrd.h and should be at lease 1. | |||
samples[SAMPLE_COUNT_MACRO] is a ring buffer. samplesIndex is it's current write index. | |||
SAMPLE_COUNT_MACRO is the number of consecutive equal samples needed to debounce. | |||
SAMPLE_COUNT_MACRO is a macro because it defines samples[SAMPLE_COUNT_MACRO] array size at compile time. | |||
SAMPLE_COUNT_MACRO is defined in config_keybrd.h and should be at lease 1. | |||
SAMPLE_COUNT = 4 is very reliable for a keyboard. | |||
SAMPLE_COUNT_MACRO = 4 is very reliable for a keyboard. | |||
Split keyboards with a long connecting wire or in environment with | |||
strong electromagnetic interference (EMI) may need a larger SAMPLE_COUNT for reliability. | |||
strong electromagnetic interference (EMI) may need a larger SAMPLE_COUNT_MACRO for reliability. | |||
*/ | |||
#include "Debouncer_Samples.h" | |||
@@ -37,18 +37,18 @@ For return, 1 means debounced changed. | |||
*/ | |||
read_pins_t Debouncer_Samples::debounce(const read_pins_t rawSignal, read_pins_t& debounced) | |||
{ | |||
read_pins_t previousDebounced; //bitwise, 1 means pressed, 0 means released | |||
read_pins_t all_1 = ~0; //bitwise | |||
read_pins_t all_0 = 0; //bitwise | |||
read_pins_t previousDebounced; //bitwise, 1 means pressed, 0 means released | |||
read_pins_t all_1 = ~0; //bitwise | |||
read_pins_t all_0 = 0; //bitwise | |||
samples[samplesIndex] = rawSignal; //insert rawSignal into samples[] ring buffer | |||
if (++samplesIndex >= SAMPLE_COUNT) //if end of ring buffer | |||
if (++samplesIndex >= SAMPLE_COUNT_MACRO) //if end of ring buffer | |||
{ | |||
samplesIndex = 0; //wrap samplesIndex to beginning of ring buffer | |||
} | |||
for (uint8_t j = 0; j < SAMPLE_COUNT; j++) //traverse the sample[] ring buffer | |||
for (uint8_t j = 0; j < SAMPLE_COUNT_MACRO; j++) //traverse the sample[] ring buffer | |||
{ | |||
all_1 &= samples[j]; //1 if all samples are 1 | |||
all_0 |= samples[j]; //0 if all samples are 0 |
@@ -7,12 +7,12 @@ | |||
#include <DebouncerInterface.h> | |||
/* Debouncer_Samples | |||
Configuration: #define SAMPLE_COUNT in config_keybrd.h | |||
Configuration: #define SAMPLE_COUNT_MACRO in config_keybrd.h | |||
*/ | |||
class Debouncer_Samples : public DebouncerInterface | |||
{ | |||
private: | |||
read_pins_t samples[SAMPLE_COUNT]; //bitwise, one bit per key, most recent readings | |||
read_pins_t samples[SAMPLE_COUNT_MACRO]; //bitwise, one bit per key, most recent readings | |||
uint8_t samplesIndex; //samples[] current write index | |||
public: | |||
Debouncer_Samples(): samplesIndex(0) {} |
@@ -5,16 +5,14 @@ | |||
/* | |||
PortRead is an abstract base class. | |||
Port classes are the keybrd library's interface to microcontoller ports or I/O expander ports. | |||
Port classes are the keybrd library's interface to microcontroller ports or I/O expander ports. | |||
*/ | |||
class PortRead | |||
{ | |||
protected: | |||
const uint8_t READ_PINS; //bitwise pin configuration, 1 means read column | |||
const uint8_t readPins; //bitwise pin configuration, 1 means read column | |||
public: | |||
PortRead(const uint8_t READ_PINS): READ_PINS(READ_PINS) {} | |||
//read port and return readState | |||
PortRead(const uint8_t readPins): readPins(readPins) {} | |||
virtual uint8_t read()=0; | |||
}; | |||
#endif |
@@ -3,20 +3,20 @@ | |||
/* | |||
configures column port's configuration, input, and pins. | |||
*/ | |||
PortRead_PCA9655E::PortRead_PCA9655E (PortIOE& port, const uint8_t READ_PINS) | |||
: PortRead(READ_PINS), port(port), configurationByteCommand(port.num + 6), inputByteCommand(port.num) | |||
PortRead_PCA9655E::PortRead_PCA9655E (PortIOE& port, const uint8_t readPins) | |||
: PortRead(readPins), port(port), configurationByteCommand(port.num + 6), inputByteCommand(port.num) | |||
{} | |||
void PortRead_PCA9655E::begin() | |||
{ | |||
Wire.beginTransmission(port.ADDR); | |||
Wire.write(configurationByteCommand); | |||
Wire.write(READ_PINS); //0=configure as output (for LED), 1=configure as input (for read) | |||
Wire.write(readPins); //0=configure as output (for LED), 1=configure as input (for read) | |||
Wire.endTransmission(); | |||
} | |||
/* | |||
Saves all port-pin values to portState. | |||
returns port value | |||
*/ | |||
uint8_t PortRead_PCA9655E::read() | |||
{ |
@@ -11,7 +11,7 @@ PCA9655E does not have internal pull-up resistors (PCA9535E does). | |||
Instantiation | |||
------------ | |||
READ_PINS parameter is port's bitwise pin configuration | |||
readPins parameter is port's bitwise pin configuration | |||
1=configure as input (for pins connected to column) | |||
0=configure as output (for LED or not connected to a column) | |||
@@ -22,11 +22,8 @@ Example instantiation for column port 1, with pins 2 and 3 connected to columns: | |||
PortIOE port1(1, 0); | |||
PortRead_PCA9655E colPort1(port1, 2<<0 | 1<<3 ); | |||
READ_PINS are read from pin 0 on up. | |||
readPins are read from pin 0 on up. | |||
Diode orientation | |||
---------------- | |||
Rows, columns, and diode orientation are explained in Matrix.h | |||
*/ | |||
class PortRead_PCA9655E : public PortRead | |||
{ | |||
@@ -36,10 +33,8 @@ class PortRead_PCA9655E : public PortRead | |||
const uint8_t inputByteCommand; | |||
public: | |||
//The constructor initialization list is in .cpp | |||
PortRead_PCA9655E(PortIOE& port, const uint8_t READ_PINS); | |||
PortRead_PCA9655E(PortIOE& port, const uint8_t readPins); | |||
void begin(); | |||
//read port and store result in portState | |||
virtual uint8_t read(); | |||
}; | |||
#endif |
@@ -5,7 +5,7 @@ | |||
/* | |||
PortWrite is an abstract base class. | |||
Port classes are the keybrd library's interface to microcontoller ports or I/O expander ports. | |||
Port classes are the keybrd library's interface to microcontroller ports or I/O expander ports. | |||
*/ | |||
class PortWrite | |||
{ |
@@ -7,8 +7,8 @@ PortWrite_PCA9655E::PortWrite_PCA9655E(PortIOE& port) | |||
: port(port), configurationByteCommand(port.num + 6), outputByteCommand(port.num + 2) {} | |||
/* | |||
If PortRead_PCA9655E is instantiated on the same port, do not use PortWrite_PCA9655E::begin(). | |||
Use PortRead_PCA9655E::begin() instead. Otherwise READ_PINS could be overwritten. | |||
If PortRead_PCA9655E is instantiated on the same port, do NOT use PortWrite_PCA9655E::begin(). | |||
Otherwise readPins could be overwritten. | |||
*/ | |||
void PortWrite_PCA9655E::begin() | |||
{ |
@@ -7,12 +7,12 @@ | |||
#include "PortIOE.h" | |||
/* One PCA9655E I/O expander port connected to matrix rows. | |||
PCA9655E does not have internal pull-up resistors (PCA9535E does). | |||
begin() configures column port's configuration and output. | |||
This should normally be called only once. | |||
If PortRead_PCA9655E is instantiated on the same port, do not use PortWrite_PCA9655E::begin(). | |||
Use PortRead_PCA9655E::begin() instead. Otherwise READ_PINS could be overwritten. | |||
This should normally be called once in sketch's setup(). | |||
If PortRead_PCA9655E is instantiated on the same port, do NOT use PortWrite_PCA9655E::begin(). | |||
Otherwise readPins could be overwritten. | |||
Instantiation | |||
------------ | |||
@@ -26,9 +26,7 @@ Example instantiation for row port 1: | |||
Diode orientation | |||
---------------- | |||
PCA9655E does not have internal pull-up resistors, external pull-down resistors are required. | |||
Rows, columns, and diode orientation are explained in Matrix.h | |||
Diode orientation is explained in keybrd_library_user_guide.md > Diode orientation | |||
PCA9655E data sheet | |||
---------------- |
@@ -17,5 +17,5 @@ void Row_ShiftRegisters::process() | |||
readState = scanner.scan(); | |||
debouncedChanged = debouncer.debounce(readState, debounced); | |||
send(READ_PIN_COUNT, debouncedChanged); | |||
send(readPinCount, debouncedChanged); | |||
} |
@@ -9,16 +9,16 @@ | |||
Instantiation | |||
------------- | |||
Definition of DELAY_MICROSECONDS is explained in Row.cpp. | |||
Scanner_ShiftRegs74HC165.h has instructions for hardware and setting active state. | |||
Example instantiation of a Row_ShiftRegisters: | |||
const uint8_t Scanner_ShiftRegs74HC165::SHIFT_LOAD = 10; | |||
const bool Scanner_ShiftRegs74HC165::STROBE_ON = LOW; //logic level of strobe on, active low | |||
const bool Scanner_ShiftRegs74HC165::STROBE_OFF = HIGH; //logic level of strobe off | |||
const bool Scanner_ShiftRegs74HC165::STROBE_ON = LOW; //active low | |||
const bool Scanner_ShiftRegs74HC165::STROBE_OFF = HIGH; | |||
Key* const ptrsKeys_0[] = { &k_00, &k_01, &k_02, &k_03, &k_04, &k_05 }; | |||
uint8_t READ_PIN_COUNT_0 = sizeof(ptrsKeys_0)/sizeof(*ptrsKeys_0); | |||
Row_ShiftRegisters row_0(1, READ_PIN_COUNT_0, ptrsKeys_0); | |||
uint8_t readPinCount_0 = sizeof(ptrsKeys_0)/sizeof(*ptrsKeys_0); | |||
Row_ShiftRegisters row_0(1, readPinCount_0, ptrsKeys_0); | |||
call begin() from sketch setup(): | |||
void setup() | |||
@@ -28,19 +28,19 @@ call begin() from sketch setup(): | |||
row_0.begin(); | |||
} | |||
READ_PIN_COUNT should equal number of keys in ptrsKeys_0[] array. | |||
if READ_PIN_COUNT is too small, a key will be unresposive | |||
if READ_PIN_COUNT is too large, the keyboard will fail in an unpredictable way | |||
readPinCount should equal number of keys in ptrsKeys_0[] array. | |||
if readPinCount is too small, a key will be unresponsive | |||
if readPinCount is too large, the keyboard will fail in an unpredictable way | |||
*/ | |||
class Row_ShiftRegisters : public Row | |||
{ | |||
private: | |||
Scanner_ShiftRegs74HC165 scanner; | |||
Debouncer_Samples debouncer; | |||
const uint8_t READ_PIN_COUNT; //number of read pins | |||
const uint8_t readPinCount; //number of read pins | |||
public: | |||
Row_ShiftRegisters(const uint8_t STROBE_PIN, const uint8_t READ_PIN_COUNT, Key *const ptrsKeys[]) | |||
: Row(ptrsKeys), scanner(STROBE_PIN, READ_PIN_COUNT), READ_PIN_COUNT(READ_PIN_COUNT) { } | |||
Row_ShiftRegisters(const uint8_t strobePin, const uint8_t readPinCount, Key *const ptrsKeys[]) | |||
: Row(ptrsKeys), scanner(strobePin, readPinCount), readPinCount(readPinCount) { } | |||
void begin(); | |||
void process(); | |||
}; |
@@ -10,5 +10,5 @@ void Row_uC::process() | |||
readState = scanner.scan(); | |||
debouncedChanged = debouncer.debounce(readState, debounced); | |||
send(READ_PIN_COUNT, debouncedChanged); | |||
send(readPinCount, debouncedChanged); | |||
} |
@@ -9,17 +9,17 @@ | |||
Instantiation | |||
------------- | |||
Definition of DELAY_MICROSECONDS is explained in Row.cpp. | |||
keybrd_library_developer_guide.md has instructions for ## Active state and diode orientation | |||
Example instantiation of a Row_uC: | |||
const bool Scanner_uC::STROBE_ON = LOW; //logic level of strobe on, active low | |||
const bool Scanner_uC::STROBE_OFF = HIGH; //logic level of strobe off | |||
const uint8_t readPins[] = {0,1,2,3,7,8}; | |||
const uint8_t READ_PIN_COUNT = sizeof(readPins)/sizeof(*readPins); | |||
const uint8_t readPinCount = sizeof(readPins)/sizeof(*readPins); | |||
Key* const ptrsKeys_0[] = { &k_00, &k_01, &k_02, &k_03, &k_04, &k_05 }; | |||
Row_uC row_0(21, readPins, READ_PIN_COUNT, ptrsKeys_0); | |||
Row_uC row_0(21, readPins, readPinCount, ptrsKeys_0); | |||
Number of readPins should equal number of keys in ptrsKeys_0[] array. | |||
if a readPins is missing, a key will be unresposive | |||
@@ -30,12 +30,12 @@ class Row_uC : public Row | |||
private: | |||
Scanner_uC scanner; | |||
Debouncer_Samples debouncer; | |||
const uint8_t READ_PIN_COUNT; | |||
const uint8_t readPinCount; | |||
public: | |||
Row_uC(const uint8_t strobePin, const uint8_t READ_PINS[], const uint8_t READ_PIN_COUNT, | |||
Row_uC(const uint8_t strobePin, const uint8_t readPins[], const uint8_t readPinCount, | |||
Key *const ptrsKeys[]) | |||
: Row(ptrsKeys), scanner(strobePin, READ_PINS, READ_PIN_COUNT), | |||
READ_PIN_COUNT(READ_PIN_COUNT) { } | |||
: Row(ptrsKeys), scanner(strobePin, readPins, readPinCount), | |||
readPinCount(readPinCount) { } | |||
void process(); | |||
}; | |||
#endif |
@@ -8,14 +8,14 @@ | |||
DELAY_MICROSECONDS explained | |||
---------------------------- | |||
A keyboard with a faster scan rate responds faster. | |||
Follow these step to tune DELAY_MICROSECONDS for maximum scan rate for a given SAMPLE_COUNT: | |||
Follow these step to tune DELAY_MICROSECONDS for maximum scan rate for a given SAMPLE_COUNT_MACRO: | |||
Intantiate DELAY_MICROSECONDS in your sketch: | |||
ScanDelay scanDelay(1000); | |||
Add this to the sketch's loop() function: | |||
debug.print_microseconds_per_scan(); | |||
Compile and load the sketch into the microcontroller; microseconds_per_scan is printed every second. | |||
Adjust the value of DELAY_MICROSECONDS and repeat until: | |||
debug.print_microseconds_per_scan() <= DEBOUNCE_TIME / SAMPLE_COUNT | |||
debug.print_microseconds_per_scan() <= DEBOUNCE_TIME / SAMPLE_COUNT_MACRO | |||
DEBOUNCE_TIME can be obtained from the switch's datasheet. Some switch bounce times are: | |||
Cherry MX specifies 5msec bounce time http://www.cherrycorp.com/english/switches/key/mx.htm |
@@ -1,6 +1,6 @@ | |||
#include "Scanner_Port.h" | |||
/* scan() strobes the row's STROBE_PIN and retuns state of port's input pins. | |||
/* scan() strobes the row's strobePin and retuns state of port's input pins. | |||
Bitwise variables are 1 bit per key. | |||
*/ | |||
uint8_t Scanner_Port::scan() | |||
@@ -8,14 +8,14 @@ uint8_t Scanner_Port::scan() | |||
uint8_t readState; //bitwise, 1 means key is pressed, 0 means released | |||
//strobe on | |||
refPortWrite.write(STROBE_PIN, STROBE_ON); | |||
delayMicroseconds(3); //time to stablize voltage | |||
refPortWrite.write(strobePin, STROBE_ON); | |||
delayMicroseconds(3); //time to stabilize voltage | |||
//read the port pins | |||
readState = refPortRead.read(); | |||
//strobe off | |||
refPortWrite.write(STROBE_PIN, STROBE_OFF); | |||
refPortWrite.write(strobePin, STROBE_OFF); | |||
return readState; | |||
} |
@@ -9,18 +9,20 @@ | |||
/* Scanner_Port uses bit manipulation to read all pins of one port. | |||
The ports are normally from an I/O Expander, but could also be ports from an AVR uC. | |||
The maximum keys per row is 8, because ports have a maximum of 8 pins each. | |||
keybrd_library_developer_guide.md has instructions for ## Active state and diode orientation | |||
*/ | |||
class Scanner_Port | |||
{ | |||
private: | |||
static const bool STROBE_ON; //HIGH or LOW logic level of strobe on, active state | |||
static const bool STROBE_OFF; //logic level of strobe off, complement of STROBE_ON | |||
PortWrite& refPortWrite; //the IC port containing the STROBE_PIN | |||
const uint8_t STROBE_PIN; //bitwise, 1 indicates IC pin connected to this row | |||
PortWrite& refPortWrite; //the IC port containing the strobePin | |||
const uint8_t strobePin; //bitwise, 1 indicates IC pin connected to this row | |||
PortRead& refPortRead; //the IC's read port | |||
public: | |||
Scanner_Port(PortWrite &refPortWrite, const uint8_t STROBE_PIN, PortRead& refPortRead) | |||
: refPortWrite(refPortWrite), STROBE_PIN(STROBE_PIN), refPortRead(refPortRead) {} | |||
Scanner_Port(PortWrite &refPortWrite, const uint8_t strobePin, PortRead& refPortRead) | |||
: refPortWrite(refPortWrite), strobePin(strobePin), refPortRead(refPortRead) {} | |||
uint8_t scan(); | |||
}; | |||
#endif |
@@ -1,11 +1,11 @@ | |||
#include "Scanner_ShiftRegs74HC165.h" | |||
//constructor | |||
Scanner_ShiftRegs74HC165::Scanner_ShiftRegs74HC165(const uint8_t STROBE_PIN, uint8_t READ_PIN_COUNT) | |||
: STROBE_PIN(STROBE_PIN), BYTE_COUNT(ceil (float(READ_PIN_COUNT)/8)) | |||
Scanner_ShiftRegs74HC165::Scanner_ShiftRegs74HC165(const uint8_t strobePin, uint8_t readPinCount) | |||
: strobePin(strobePin), byte_count(ceil (float(readPinCount)/8)) | |||
{ | |||
//configure controller to communicate with shift register matrix | |||
pinMode(STROBE_PIN, OUTPUT); | |||
pinMode(strobePin, OUTPUT); | |||
pinMode(SHIFT_LOAD, OUTPUT); | |||
} | |||
@@ -15,7 +15,7 @@ void Scanner_ShiftRegs74HC165::begin() | |||
digitalWrite(SHIFT_LOAD, HIGH); | |||
} | |||
/* scan() strobes the row's STROBE_PIN and retuns state of the shift register's input pins. | |||
/* scan() strobes the row's strobePin and retuns state of the shift register's input pins. | |||
Bitwise variables are 1 bit per key. | |||
*/ | |||
read_pins_t Scanner_ShiftRegs74HC165::scan() | |||
@@ -23,16 +23,16 @@ read_pins_t Scanner_ShiftRegs74HC165::scan() | |||
read_pins_t readState = 0; //bitwise, 1 means key is pressed, 0 means released | |||
//strobe row on | |||
digitalWrite(STROBE_PIN, STROBE_ON); | |||
digitalWrite(strobePin, STROBE_ON); | |||
delayMicroseconds(3); //time to stablize voltage | |||
//read all the column pins | |||
digitalWrite(SHIFT_LOAD, LOW); //load parallel inputs to the register | |||
digitalWrite(SHIFT_LOAD, HIGH); //shift the data toward a serial output | |||
SPI.transfer(&readState, BYTE_COUNT); | |||
SPI.transfer(&readState, byte_count); | |||
//strobe row off | |||
digitalWrite(STROBE_PIN, STROBE_OFF); | |||
digitalWrite(strobePin, STROBE_OFF); | |||
//for testing on breadboard, clear unpowered pins | |||
readState &= 0b11110001000100010001000100010001; //todo delete this line |
@@ -13,25 +13,22 @@ shift registers 74HC165 are Parallel-In-Serial-Out (PISO) | |||
Upto 4 shift registers can be in a daisy chained for a total of 32 read pins. | |||
For active low: | |||
Shift register parallel input pins have 10k pull-down resistors powered | |||
Orient diodes with cathode (banded end) towards the write pins (row) | |||
Controller's MISO pin is connected to shift register's complementary serial output (/QH) pin | |||
Use these two lines in the sketch: | |||
const bool Scanner_ShiftRegs74HC165::STROBE_ON = LOW; | |||
const bool Scanner_ShiftRegs74HC165::STROBE_OFF = HIGH; | |||
//shift register parallel input pins have 10k pull-down resistors powered | |||
//controller's MISO pin is connected to shift register's complementary serial output (/QH) pin | |||
For active high: | |||
Shift register parallel input pins have 10k pull-down resistors grounded | |||
Orient diodes with cathode (banded end) towards the read pins. | |||
Controller's MISO pin is connected to shift register's serial output (QH) pin | |||
Use these two lines in the sketch: | |||
const bool Scanner_ShiftRegs74HC165::STROBE_ON = HIGH; | |||
const bool Scanner_ShiftRegs74HC165::STROBE_OFF = LOW; | |||
//shift register parallel input pins have 10k pull-down resistors grounded | |||
//controller's MISO pin is connected to shift register's serial output (QH) pin | |||
In addition, each row needs to be connected to a strobe pin from the controller. | |||
todo move this to tutorial | |||
The shift register needs 5 wires. | |||
The two parts of a split keyboard can be connected by one of: | |||
* eSATA cable (has 7 wires, good for 2 rows) | |||
* Ethernet cable (has 8 wires, good for 3 rows) | |||
*/ | |||
class Scanner_ShiftRegs74HC165 | |||
{ | |||
@@ -39,10 +36,10 @@ class Scanner_ShiftRegs74HC165 | |||
static const uint8_t SHIFT_LOAD; //controller's pin number that is connected to shift register's SHIFT_LOAD pin | |||
static const bool STROBE_ON; //logic level of strobe on, active state HIGH or LOW | |||
static const bool STROBE_OFF; //logic level of strobe off, complement of active state | |||
const uint8_t STROBE_PIN; //Arduino pin number connected to this row | |||
const uint8_t BYTE_COUNT; //number of bytes to read from shift registers | |||
const uint8_t strobePin; //Arduino pin number connected to this row | |||
const uint8_t byte_count; //number of bytes to read from shift registers | |||
public: | |||
Scanner_ShiftRegs74HC165(const uint8_t STROBE_PIN, const uint8_t READ_PIN_COUNT); | |||
Scanner_ShiftRegs74HC165(const uint8_t strobePin, const uint8_t readPinCount); | |||
virtual read_pins_t scan(); | |||
void begin(); | |||
}; |
@@ -10,14 +10,14 @@ https://www.arduino.cc/en/Reference/Constants > Digital Pins modes: INPUT, INPUT | |||
/* constructor | |||
*/ | |||
Scanner_uC::Scanner_uC(const uint8_t STROBE_PIN, | |||
const uint8_t READ_PINS[], const uint8_t READ_PIN_COUNT) | |||
: STROBE_PIN(STROBE_PIN), READ_PINS(READ_PINS), READ_PIN_COUNT(READ_PIN_COUNT) | |||
Scanner_uC::Scanner_uC(const uint8_t strobePin, | |||
const uint8_t readPins[], const uint8_t readPinCount) | |||
: strobePin(strobePin), readPins(readPins), readPinCount(readPinCount) | |||
{ | |||
uint8_t mode; | |||
//configure row | |||
pinMode(STROBE_PIN, OUTPUT); | |||
pinMode(strobePin, OUTPUT); | |||
if (STROBE_ON == LOW) //if active low | |||
{ | |||
@@ -29,13 +29,13 @@ Scanner_uC::Scanner_uC(const uint8_t STROBE_PIN, | |||
} | |||
//configure read pins | |||
for (uint8_t i=0; i < READ_PIN_COUNT; i++) | |||
for (uint8_t i=0; i < readPinCount; i++) | |||
{ | |||
pinMode(READ_PINS[i], mode); | |||
pinMode(readPins[i], mode); | |||
} | |||
} | |||
/* scan() strobes the row's STROBE_PIN and retuns state of READ_PINS. | |||
/* scan() strobes the row's strobePin and retuns state of readPins. | |||
Bitwise variables are 1 bit per key. | |||
*/ | |||
read_pins_t Scanner_uC::scan() | |||
@@ -44,13 +44,13 @@ read_pins_t Scanner_uC::scan() | |||
read_pins_t readMask = 1; //bitwise, active bit is 1 | |||
//strobe row on | |||
digitalWrite(STROBE_PIN, STROBE_ON); | |||
digitalWrite(strobePin, STROBE_ON); | |||
delayMicroseconds(3); //time to stablize voltage | |||
//read all the read pins | |||
for (uint8_t i=0; i < READ_PIN_COUNT; i++) | |||
for (uint8_t i=0; i < readPinCount; i++) | |||
{ | |||
if ( digitalRead(READ_PINS[i]) == STROBE_ON ) | |||
if ( digitalRead(readPins[i]) == STROBE_ON ) | |||
{ | |||
readState |= readMask; | |||
} | |||
@@ -58,7 +58,7 @@ read_pins_t Scanner_uC::scan() | |||
} | |||
//strobe row off | |||
digitalWrite(STROBE_PIN, STROBE_OFF); | |||
digitalWrite(strobePin, STROBE_OFF); | |||
return readState; | |||
} |
@@ -15,12 +15,12 @@ class Scanner_uC | |||
private: | |||
static const bool STROBE_ON; //logic level of strobe on, HIGH or LOW | |||
static const bool STROBE_OFF; //logic level of strobe off, complement of STROBE_ON | |||
const uint8_t STROBE_PIN; //Arduino pin number connected to this row | |||
const uint8_t* const READ_PINS; //array of read pin numbers | |||
const uint8_t READ_PIN_COUNT; //number of read pins | |||
const uint8_t strobePin; //Arduino pin number connected to this row | |||
const uint8_t* const readPins; //array of read pin numbers | |||
const uint8_t readPinCount; //number of read pins | |||
public: | |||
Scanner_uC(const uint8_t STROBE_PIN, | |||
const uint8_t READ_PINS[], const uint8_t READ_PIN_COUNT); | |||
Scanner_uC(const uint8_t strobePin, | |||
const uint8_t readPins[], const uint8_t readPinCount); | |||
virtual read_pins_t scan(); | |||
}; | |||
#endif |
@@ -9,19 +9,19 @@ Using smaller types on a 32-bit uC (Teensy LC) would accomplish nothing. | |||
*/ | |||
/* Use a read_pins_t size that covers all read pins of all RowScanner objects i.e. | |||
For Scanner_uC, Scanner_uC::READ_PIN_COUNT | |||
For Scanner_ShiftRegs74HC165, Scanner_ShiftRegs74HC165::READ_PIN_COUNT | |||
For Scanner_uC, Scanner_uC::readPinCount | |||
For Scanner_ShiftRegs74HC165, Scanner_ShiftRegs74HC165::readPinCount | |||
For Scanner_Port, cover the last 1 bit in Scanner_Port::strobePin | |||
*/ | |||
//typedef uint8_t read_pins_t; | |||
//typedef uint16_t read_pins_t; | |||
typedef uint32_t read_pins_t; | |||
/* SAMPLE_COUNT is used in Debouncer_Samples.h | |||
SAMPLE_COUNT = 4 is very reliable for a keyboard. | |||
/* SAMPLE_COUNT_MACRO is used in Debouncer_Samples.h | |||
SAMPLE_COUNT_MACRO = 4 is very reliable for a keyboard. | |||
Split keyboards with a long connecting wire or in environment with | |||
strong electromagnetic interference (EMI) may need a larger SAMPLE_COUNT for reliability. | |||
strong electromagnetic interference (EMI) may need a larger SAMPLE_COUNT_MACRO for reliability. | |||
*/ | |||
#define SAMPLE_COUNT 4 //number of consecutive equal bits needed to change a debounced bit | |||
#define SAMPLE_COUNT_MACRO 4 //number of consecutive equal bits needed to change a debounced bit | |||
#endif |
@@ -3,7 +3,6 @@ | |||
This sketch: | |||
is a simple 1-layer keyboard | |||
runs on the first two rows and columns of a breadboard keyboard | |||
is annotated with a walk-through narrative | |||
This layout table shows how keys are arranged on the keyboard: | |||
@@ -45,7 +45,7 @@ The basic breadboard has 4 switches and a microcontroller. | |||
The key matrix has two rows and two columns. | |||
Breadboard bus strips are used as matrix rows. | |||
Short bare wires connect terminal strips into matrix columns. | |||
Short wires connect terminal strips into matrix columns. | |||
Switch-diode pairs connect rows to columns. | |||
The green rectangle on the right is the Teensy 2.0 microcontroller. | |||
@@ -63,8 +63,8 @@ Breadboard keyboard assembly instructions: | |||
* diodes 22 to 24 mm total end-to-end length, and save the cut offs for steps 2 and 3 | |||
2. Insert parts into the breadboard as shown in the picture. | |||
* Teensy LC on the terminal strip labeled 1 | |||
* switch leads oriented so that they will connect diodes to columns | |||
* diode cut offs connect terminal strips into columns | |||
* switch leads are oriented to connect diodes to columns | |||
* diodes are orient with cathode (banded end) towards the row (bus strip) | |||
3. Insert jumper wires connecting Teensy2 to the matrix rows and columns. | |||
* follow pin connections table (below) and consult pinout diagram in |