7 vuotta sitten · 36d0ed3579
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
 * Limit the first line to 72 characters summary 
 * Second line should be empty, followed by body of the commit message 
 * Use the imperative present tense (use "Add feature", not "Added feature", not "Adds feature") 
 * Reference an improvement suggestion or bug report 
 * Reference an improvement suggestion, bug report, or planned_features 
 * Sometimes a bulleted list is a good format to convey the changes of a commit 
 User contributions 
--- a/doc/CHANGELOG.md
+++ b/doc/CHANGELOG.md
 * 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 
 * Arduino boards, Teensy 3, and Teensy LC microcontrollers 
 * up to 31x31 matrix capability 
 * Change IOE from scanning port arrays to scanning single ports. 
 * Move scanner and debouncer into their own classes. 
 0.2.0 (2016-02-25) 
 ------------------ 
 * Enhancements 
 * Add Port classes for micro-controllers and I/O expanders 
 * Add Port classes for microcontrollers and I/O expanders 
 * Add DH_2565 sketch with DataHand layout 
 * Add Sticky mouse button (SMB) for DataHand layout 
 * Add Supporting documentation 
--- a/doc/PLANNED_FEATURES.md
+++ b/doc/PLANNED_FEATURES.md
 planned_features is a view of where the keybrd project is headed. 
 Top priority 
 ============ 
 ------------ 
 * Beta testing 
 * Schematics for tutorials 
 * Add breadboard keyboard schematics to tutorials 
 Medium priority 
 =============== 
 --------------- 
 * Add matrix-to-layout mapping array (to decouple key matrix from layout) 
 * Add tutorial_4b_split_keyboard_with_shift_registers 
 Low priority 
 ============ 
 * MCP23S18 I/O expander with Serial Peripheral Interface (SPI) 
 ------------ 
 * Add MCP23S18 I/O expander with Serial Peripheral Interface (SPI) 
--- a/doc/keybrd_library_developer_guide.md
+++ b/doc/keybrd_library_developer_guide.md
 Who this guide is for 
 --------------------- 
 This guide is for the maintainers and developers of the keybrd library and it's extensions. 
 It is assumed the reader is familiar with C++ language including pointers, objects, classes, static class variables, composition, aggregation, inheritance, polymorphism, and enum. 
 It is assumed the reader is familiar with the C++ language including pointers, objects, classes, static class variables, composition, aggregation, inheritance, polymorphism, and enum. 
 Row, Scanner, and Debouncer classes use bit manipulation. 
 Custom Row classes 
 ------------------ 
 Row classes are central to the keybrd library. 
 Row is an abstract base class that allows flexibility for designing derived Row classes: 
 Row is an abstract base class that allows flexibility in designing derived Row classes: 
 * Row functions can be overridden in a derived class 
 * choice of Debouncers 
 * choice of Scanners 
 This example illustrates the custom Row classes for a fictional keybrd_Ext extension library. 
 The keybrd_Ext library is for a split keyboard with sticky keys and a matrix on each hand. 
 The keybrd_Ext library is for a split keyboard with a matrix on each hand and sticky keys. 
 Row_Ext::keyWasPressed() overrides Row::keyWasPressed()<br> 
 Row_Ext::keyWasPressed() is used to unstick sticky keys 
 Row_Ext::keyWasPressed() overrides Row::keyWasPressed() which is used to unstick sticky keys. 
 Row_Ext_uC and Row_Ext_ShiftRegisters are a custom classes composed of stock keybrd library classes.<br> 
 Row_Ext_uC uses Scanner_uC to scan the primary matrix.<br> 
 Layer-class naming conventions 
 ------------------------------ 
 Layer classes are explained in [tutorial_3a_multi-layer_keyboard.md](../tutorials/tutorial_3a_multi-layer_keyboard.md). 
 *Code_Layer* class names are concatenations of "Code_", "Layer" or layer name, and persistence. 
 Example persistences are: 
 * "Lock" - layer remains active after the layer key is released 
--- a/doc/keybrd_library_user_guide.md
+++ b/doc/keybrd_library_user_guide.md
 Microcontroller board requirements 
 ---------------------------------- 
 The keybrd library works with Teensy and Arduino compatible boards. 
 The keybrd library works with Teensy and Arduino compatible boards with at least 2 KB SRAM. 
 [Teensy LC](https://www.pjrc.com/teensy/teensyLC.html) has 8K RAM, which is more than enough memory for any keyboard. 
 keybrd has been tested on the DodoHand keyboard with Teensy 2.0 and PCA9655E I/O expander using the keybrd_DH sketch. 
 Teensy LC is preferred over the older Teensy 2.0 for it's larger memory capacity and lower price. 
 [Teensy LC](https://www.pjrc.com/teensy/teensyLC.html) is the preferred board for the keybrd library and is used in the tutorials. Teensy LC has 8 KB SRAM, which is enough memory for any keyboard. 
 Getting started with Teensy, Arduino IDE, and keybrd 
 ---------------------------------------------------- 
 [Teensy Getting Started](http://www.pjrc.com/teensy/first_use.html) is a good way to familiarize yourself with Teensy. 
 [Arduino Development Environment](http://arduino.cc/en/guide/Environment) is a brief description. 
 The following install and setup steps create an Arduino development environment for keybrd sketches. 
 The following steps create an Arduino development environment for keybrd sketches. 
 ### Install Arduino IDE and Teensyduino 
 The following install steps are modified from the [Teensyduino download page](https://www.pjrc.com/teensy/td_download.html). 
 Instructions for installing Arduino libraries are at: http://www.arduino.cc/en/Guide/Libraries 
 A Sketchbook is a folder that the Arduino IDE uses to store sketches and libraries. 
 The default location for Arduino libraries is ~/Documents/Arduino/libraries/. 
 For example, the DodoHand keyboard requires the core keybrd library and the keybrd_DH extension library. 
 For example, the DodoHand keyboard requires the core keybrd library and the keybrd_DH extension library be installed. 
 After installing the libraries, my Arduino directory looks like this: 
 * ~/Documents/Arduino/libraries/keybrd/ 
 * ~/Documents/Arduino/libraries/keybrd_DH/ 
 where 
 * **keybrd** is the library name e.g. keybrd, keybrd_DH 
 * **feature** is a distinguishing feature of the keybrd sketch e.g. keyboard name, sound, Dvorak 
 * **feature** is a distinguishing feature of the keybrd sketch e.g. keyboard name, sound, layout 
 * **version** is the sketch's version number (optional) 
 Active state and diode orientation 
 For active low: 
 * Orient diodes with cathode (banded end) towards the write pins (row) 
 * Use these two lines in the sketch: 
 * Define strobe on and strobe off in the sketch like this: 
 ``` 
 const bool Scanner_uC::STROBE_ON = LOW; 
 const bool Scanner_uC::STROBE_OFF = HIGH; 
 For active high: 
 * Add an external 10k pull-down resistor to each read pin. 
 * Orient diodes with cathode (banded end) towards the read pins. 
 * Use these two lines in the sketch: 
 * Define strobe on and strobe off in the sketch like this: 
 ``` 
 const bool Scanner_uC::STROBE_ON = HIGH; 
 const bool Scanner_uC::STROBE_OFF = LOW; 
 'KEY_A' was not declared in this scope 
 ``` 
 Where 'KEY_A' could be any scan code. 
 Fix this from the Arduino IDE tool bar: Tools > USB Type > Keyboard + Mouse + Joystick 
 Fix this error from the Arduino IDE tool bar: Tools > USB Type > Keyboard + Mouse + Joystick 
 Sketch items to check: 
 * For each row, number of read pins in Row should equal number of keys. 
 * For multi-layered keyboards, the number of codes in each Key_Layered should equal the number of layers. 
 Hardware items to check: 
 * Connections 
 * Diode orientation 
 * Continuity of connections 
 * 3.3 or 5 volts across power and ground 
 * Diode orientation 
 * To validate keyboard hardware, modify the simple [keybrd_1_breadboard.ino](../tutorials/keybrd_1_breadboard/keybrd_1_breadboard.ino) sketch. 
 Keybrd nomenclature 
--- a/src/Row_uC.h
+++ b/src/Row_uC.h
 #include <Scanner_uC.h>
 #include <Debouncer_Samples.h>
 /* Row_uC is a row connected to a micro controller.
 /* Row_uC is a row connected to a microcontroller.
 Instantiation
 -------------
--- a/tutorials/keybrd_2_single-layer/keybrd_2_single-layer.ino
+++ b/tutorials/keybrd_2_single-layer/keybrd_2_single-layer.ino
 const bool Scanner_uC::STROBE_OFF = HIGH;
 /* ================= PINS =================
 Micro-controller 14 and 15 are connected to the matrix columns.
 Microcontroller 14 and 15 are connected to the matrix columns.
 These readPins detect which keys are pressed while a row is strobed.
 sizeof() is used to compute the number of array elements.
--- a/tutorials/tutorial_0_introduction.md
+++ b/tutorials/tutorial_0_introduction.md
 Tutorial 0 - Introduction
 =========================
 The first two tutorials are intended to be read in sequence:
 * Tutorial 1 builds a breadboard keyboard
 * Tutorial 2 covers basic keyboard knowledge needed to understand the remaining tutorials.
 * Tutorial 1 builds a breadboard keyboard and covers basic keyboard-hardware knowledge.
 * Tutorial 2 covers basic keybrd sketch knowledge needed to understand the remaining tutorials.
 Tutorials from 3 up can be read in any order.
 Tutorials 2 through 7 use the keyboard breadboard that was built in tutorial 1.
 The tutorials assume the reader:
 * is familiar with C++
 * is new to Arduino, firmware, controllers, and the internal workings of keyboards
 * is new to Arduino, firmware, microcontrollers, and the internal workings of keyboards
 <br>
 <a rel="license" href="https://creativecommons.org/licenses/by/4.0/"><img alt="Creative Commons License" style="border-width:0" src="https://licensebuttons.net/l/by/4.0/88x31.png" /></a><br /><span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">keybrd tutorial</span> by <a xmlns:cc="https://creativecommons.org/ns" href="https://github.com/wolfv6/keybrd" property="cc:attributionName" rel="cc:attributionURL">Wolfram Volpi</a> is licensed under a <a rel="license" href="https://creativecommons.org/licenses/by/4.0/">Creative Commons Attribution 4.0 International License</a>.<br />Permissions beyond the scope of this license may be available at <a xmlns:cc="https://creativecommons.org/ns" href="https://github.com/wolfv6/keybrd/issues/new" rel="cc:morePermissions">https://github.com/wolfv6/keybrd/issues/new</a>.
--- a/tutorials/tutorial_10_writing_your_own_port_classes.md
+++ b/tutorials/tutorial_10_writing_your_own_port_classes.md
 Port classes are the keybrd library's interface to I/O expander ports.
 To write your own port classes:
 1. Get a copy of the controller or I/O expander datasheet.
 2. Study other keybrd Port classes.
--- a/tutorials/tutorial_1_breadboard_keyboard.md
+++ b/tutorials/tutorial_1_breadboard_keyboard.md
 * A small keyboard is easier to trouble shoot 
 Breadboard keyboards are useful for: 
 * learning keyboard electronics - micro controller, key matrix, diode, shift registers, I/O expander 
 * learning keyboard electronics - microcontroller, key matrix, diode, shift registers, I/O expander 
 * learning the firmware development workflow 
 * prototyping circuits before making a PCB 
 Breadboard keyboard starter kit 
 ------------------------------- 
 The parts needed to build the tutorial Breadboard Keyboards are listed in [breadboard_keyboard_supplies.ods](breadboard_keyboard_supplies.ods). 
 The parts needed to build the tutorial breadboard keyboards are listed in [breadboard_keyboard_supplies.ods](breadboard_keyboard_supplies.ods). 
 The tutorials use a Teensy LC controller, but any Arduino-compatible controller with SRAM should work. 
 The tutorials use a Teensy LC controller, but any Arduino-compatible controller with at least 2 KB SRAM should work. 
 You will need two tools: 
 * Wire cutters 
 * A multi-meter for trouble shooting 
 Wire striper and lead forming tool are optional. 
 Wire striper, lead-forming tool, and Anti-static mat are optional. 
 How a breadboard works 
 ---------------------- 
 These are explained in [How to Use a Breadboard](https://learn.sparkfun.com/tutorials/how-to-use-a-breadboard) 
 Electrostatic discharge (ESD) safety 
 ------------------------------------ 
 Static electricity can damage a microcontroller in ways that are hard to trouble shoot. 
 I live in a desert on a carpeted floor and get zapped by door knobs regularly. 
 Whenever I handle microcontrollers I: 
 1. Touch the bare metal on the back of my desktop computer (its grounded). 
 2. Then while still touching to the computer, touch the metal USB connector case on the microcontroller. 
 Anti-static mat or anti-static wristband are also effective. 
 Being tethered by an anti-static wristband can be inconvenient (wireless antistatic wrist straps are a scam). 
 Not everyone needs to take ESD precautions: 
 * http://forum.arduino.cc/index.php?topic=4643.0 
 * https://forums.adafruit.com/viewtopic.php?f=8&t=12128 
 Building a basic breadboard keyboard 
 ------------------------------------ 
 The basic breadboard keyboard has 4 switches. 
 ![basic breadboard keyboard](keybrd_1_breadboard/breadboard_keyboard_2x2.JPG "basic breadboard keyboard") 
 A Teensy LC microcontroller in on the left. 
 A Teensy LC microcontroller is on the left. 
 A key matrix with 4 switches is to the right. 
 The key matrix has two two columns. 
 * Teensy LC is on the left 
 * switch leads are oriented to connect diodes to columns (pictured below) 
 * diode cut offs connect terminal strips into columns 
 * diodes connect switches to blue buses, orient with cathode (banded end) towards the row (bus strip) 
 * diodes connect switches to blue buses; orient diodes with cathode (banded end) towards the row (bus strip) 
 ![switch orientation](keybrd_1_breadboard/switch_orientation.JPG "switch orientation") 
 In the article: 
 output pins power columns and input pins detect the power on rows. 
 > Output pins power columns and input pins detect the power on rows. 
 The breadboard keyboards in this series of tutorials do it the other way: 
 output pins power rows and input pins detect the power on columns. 
 > Output pins power rows and input pins detect the power on columns. 
 The keybrd library uses the word "strobe". 
 Strobe pins are output pins connected to rows. 
--- a/tutorials/tutorial_2_single-layer_keyboard.md
+++ b/tutorials/tutorial_2_single-layer_keyboard.md
 Exercises 
 --------- 
 1) Read some of the class definitions used in the sketch. 
 The classes are defined in the [keybrd library](../src/). 
 1) Read the three class definitions #included in the sketch. 
 Classes are defined in the [keybrd library](../src/). 
 2) Add a third column to the breadboard keyboard and sketch. 
 | Layout |**0**|**1**|**2**| 
 |:------:|:---:|:---:|:---:| 
 | **0** | k | e | y | 
 | **1** | b | r | d | 
 <br> 
 <a rel="license" href="https://creativecommons.org/licenses/by/4.0/"><img alt="Creative Commons License" style="border-width:0" src="https://licensebuttons.net/l/by/4.0/88x31.png" /></a><br /><span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">keybrd tutorial</span> by <a xmlns:cc="https://creativecommons.org/ns" href="https://github.com/wolfv6/keybrd" property="cc:attributionName" rel="cc:attributionURL">Wolfram Volpi</a> is licensed under a <a rel="license" href="https://creativecommons.org/licenses/by/4.0/">Creative Commons Attribution 4.0 International License</a>.<br />Permissions beyond the scope of this license may be available at <a xmlns:cc="https://creativecommons.org/ns" href="https://github.com/wolfv6/keybrd/issues/new" rel="cc:morePermissions">https://github.com/wolfv6/keybrd/issues/new</a>. 
--- a/tutorials/tutorial_3a_multi-layer_keyboard.md
+++ b/tutorials/tutorial_3a_multi-layer_keyboard.md
 Tutorial 3a - multi-layer keyboard 
 ================================== 
 When you finish this tutorial you will be able to be able to modify a multi-layer keybrd sketch to write your very own multi-layer keyboard design. 
 When you finish this tutorial you will be able to be able to modify a multi-layer keybrd sketch to write your very own multi-layer keyboard firmware. 
 Multi-layer nomenclature 
 ------------------------ 
--- a/tutorials/tutorial_3b_autoShift.md
+++ b/tutorials/tutorial_3b_autoShift.md
 | Layout | **0** | **1** | 
 |:------:|:-----:|:-----:| 
 | **0** | a ! 6 | b @ 7 | 
 | **1** |. sym .|. num .| 
 | **1** | sym |. num .| 
 <br> 
 <a rel="license" href="https://creativecommons.org/licenses/by/4.0/"><img alt="Creative Commons License" style="border-width:0" src="https://licensebuttons.net/l/by/4.0/88x31.png" /></a><br /><span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">keybrd tutorial</span> by <a xmlns:cc="https://creativecommons.org/ns" href="https://github.com/wolfv6/keybrd" property="cc:attributionName" rel="cc:attributionURL">Wolfram Volpi</a> is licensed under a <a rel="license" href="https://creativecommons.org/licenses/by/4.0/">Creative Commons Attribution 4.0 International License</a>.<br />Permissions beyond the scope of this license may be available at <a xmlns:cc="https://creativecommons.org/ns" href="https://github.com/wolfv6/keybrd/issues/new" rel="cc:morePermissions">https://github.com/wolfv6/keybrd/issues/new</a>. 
--- a/tutorials/tutorial_5_LEDs.md
+++ b/tutorials/tutorial_5_LEDs.md
 ---------
 1) In this exercise you will calculate the minimum current limiting resistance needed for your output pin and LED.
 For your micro controller, find:
 For your microcontroller, find:
 * Supply Voltage coming out of the output pins
 * Current (mA) capacity of the output pins
--- a/tutorials/tutorial_8b_creating_and_publishing_your_own_keybrd_extension_library.md
+++ b/tutorials/tutorial_8b_creating_and_publishing_your_own_keybrd_extension_library.md
 sentence=An extension to the keybrd library for the MyKeyboard.
 paragraph=This library demonstrates my feature.
 category=Device Control
 url= (github repo URL for keybrd_MyKeyboard)
 url= (instert your github repo URL for keybrd_MyKeyboard)
 architectures=*
 ```
--- a/tutorials/tutorial_9_breaking_up_a_sketch_into_smaller_files.md
+++ b/tutorials/tutorial_9_breaking_up_a_sketch_into_smaller_files.md
 Example 2.
 You use Colemak and want QWERTY users to to try your new keyboard design.
 So you publish your keybrd extension library with two versions of instantiations_matrix.h:
 * instantiations_matrix_colemak.h
 * instantiations_matrix_QWERTY.h
 * instantiations_rows_colemak.h
 * instantiations_rows_QWERTY.h
 <br>
 <a rel="license" href="https://creativecommons.org/licenses/by/4.0/"><img alt="Creative Commons License" style="border-width:0" src="https://licensebuttons.net/l/by/4.0/88x31.png" /></a><br /><span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">keybrd tutorial</span> by <a xmlns:cc="https://creativecommons.org/ns" href="https://github.com/wolfv6/keybrd" property="cc:attributionName" rel="cc:attributionURL">Wolfram Volpi</a> is licensed under a <a rel="license" href="https://creativecommons.org/licenses/by/4.0/">Creative Commons Attribution 4.0 International License</a>.<br />Permissions beyond the scope of this license may be available at <a xmlns:cc="https://creativecommons.org/ns" href="https://github.com/wolfv6/keybrd/issues/new" rel="cc:morePermissions">https://github.com/wolfv6/keybrd/issues/new</a>.