Apple-1-HW
/
unified_retro_keyboard
mirror of https://github.com/osiweb/unified_retro_keyboard.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

first commit

This commit is contained in:
Dave 2019-12-12 14:46:29 -06:00
commit 784805adc7
80 changed files with 33351 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
README.md Normal file
View File

@ -0,0 +1,26 @@
## Universal ASCII Keyboard
This project aims to provide a (near) universal ASCII keyboard for vintage computers. Home computers of the 1970's typically either polled a switch matrix, or interfaced to a parallel ASCII keyboard via a parallel port.
The keyboard will allow use of Cherry MX keys, or Futaba MD-4PCS keys.
The keyboard supports diodes per-switch for true N-key rollover, or
per-row (like the OSI).
The keyboard is designed using KiCad in order to be the most useful for anybody wishing to modify the keyboard for more specific uses, or to add to the project.
Goals for the keyboard:
- Drop in replacement for Ohio Scientific polled keyboards
-- Done: drop in for OSI 542 (untested).
-- Done: keycap set available
-- To do: module for advanced 542B/C features
- Drop in replacement for Apple II keyboard
--To do: Add-in ASCII module required
--To do: Add power light and power light cover
--To do: Special Apple keycaps needed.
- Standard ASCII parallel keyboard
-- Done: Keycap set available
-- To do: Add-in ASCII keyboard

126
firmware/asdf/README.md Normal file
View File

@ -0,0 +1,126 @@
-*- text -*-
- asdf Keyboard scanning firmware
The ASDF (Auto Scan by DF) firmware is a key matrix scanner that can detect and
debounce keypress and release events on a key matrix and either send codes or
perform actions on keypress or release. Keymaps are defined per application and
may, for example, generate ASCII codes, special keyscan codes, etc. The code is
modular and may be integrated into a larger system easily.
By default, the code supports any number of rows by 8 columns, which will give
the bestperformance on an 8-bit microcontroller. For more than 8 columns per
row, the row datatype would need to be changed to uint16_t to support 16
columns, etc.
The first supported application is a parallel ASCII output keyboard. If you want
serial or USB output, you can supply your own routines.
ASDF supports basic keyboard functionality and is configurable via a few
boolean variables, and via the key maps. The key maps are organized in
row,column format, with separate keymaps shift, capslock, and control-key modes.
Features:
* modifiers: A set of modifier keys may be specified. When only a few modifiers
are used, this mechanism is a low-overhead alternative to a keymap overlay for
keyboard states that only change the key value, such as SHIFT, CAPS LOCK, CONTROL,
etc. The state of each modifier key is kept in a state variable. In most
cases, pressing the key will set the value to a "pressed" state, and releasing
will reset the value to an "unpressed" state. However some functions interact.
For example, Shift Lock is sticky, so pressing Shift Lock toggles the Shift
Lock state, and Releasing Shift Lock does nothing; but pressing "Shift" will
reset the "Shift Lock" state.
All modifier state variables are kept in a modifier state variable array. On a
regular keypress, all of the modifier state variables are OR'ed together to
produce an index into a value array for the standard key, to determine the
value sent by the standard keypress.
* DIP switches: DIP switches are implemented by adding them into the key
matrix, and providing activate() and deactivate() functions for the on and off
positions.
* Spinners/rotary encoders: Rotary encoders can be implemented by adding the
encoder switches into the matrix, and driving the encoder state machine via
the activate() and deactivate() functions.
* sticky keys: Stick keys remain active until another key is pressed. This
functionality is supported by the per-key activate() and deactivate() functions.
For example, for sticky "control", replace control_deactivate() with
null_deactivate() as the deactivate function for the control key, and add a
call to "control_deactivate()" in the "standard_keypress_postprocess_hook()" function.
* Indicators: Controlled via activate() and deactivate() functions for the various keys.
* Debounce and Repeat functions: The main keyscan logic implements key
debouncing. Multiple keys may be debounced simultaneously using a separate
debounce counter for each key in the matrix.
* Repeat key and Autorepeat: This is provided by the repeat module. Autorepeat
may be disabled or enabled either by configuration, by activate()/deactivate()
functions, or other keyboard logic. Repeat and autorepeat only apply to the
most recently pressed key.
* (Future feature) NVRAM: For architectures that support EEPROM or other non-volatile storage,
configuration parameters are stored in non-volatile storage to survive a power
cycle.
* ASCII output - supported via output_value function.
* (Future feature) Serial, USB CDC, USB HID interfaces - supportable via output_value function.
* Indicator LEDs and other direct logic-level hardware controls: supported via
per-key activate/deactivate functions, and also via hooks to standard key
functions.
Compiling and configuration
The source files are in the ./src directory. The final build files go in the ./build directory.
To build, enter the ./src directory. You should be able to build a binary and
hex file suitable for programming a microcontroller by typing "Make". You may
edit the Makefile to specify your target platform (default is Atmega328P ASCII
controller). You may also wish to edit your preferences in "asdf_config.h" to
specify repeat timings, optimize the debounce setting (if you have very bounce
keys), and specify the character output buffer size (if you are implementing
macros, etc.)
Porting
This firmware was written in modular, portable C99, to be compiled with GCC
(avr-gcc for the Atmega). The hardware-sepecific files are in Arch/*.[ch]. To
adapt the Atmega port for additional hardware, enter the ./src/Arch directory,
and copy the files asdf_arch_atmega328p.c and asdf_arch_astmega328p.h to new
filenames, and edit them to suit the hardware changes.
The firmware is designed to run from ROM on a slow vintage processor, with a
small RAM footprint, and is not re-entrant. It is designed to compile on small
architectures, or to be hand-translated to assembly on small processors, or to
an HDL for a CPLD or FPGA.
The code was written to favor readability over cleverness. While tempted to
optimize bit testing via bithacks, I opted for code simplicity since the
performance benefit was not there for 8-bit values.
To port to a new processor architecture, you may use the atmega328p files as an
example, and create a pair of architecture-specific .c and .h files for the new
hardware, exporting the following functions:
- asdf_arch_init: initializes the CPU and hardware
- asdf_arch_read_row: given a row number, output the row to the matrix, and read
all the columns on that row asdf_arch_send_code
- asdf_arch_send_code: given a key code, output the code to the computer, via
serial, parallel, I2C, whatever is appropriate.
- asdf_arch_tick: true once every 1ms. This tests a flag set in an interrupt
routine that is triggered every 1ms. The function return value is polled and a
keyscan initiated when true. An alternative, if you have an RTOS, or even just
a scheduler, would be to schedule the keyscan every 1 ms, rather than poll. In
that case, this function is not needed, and the "superloop" in main.c would
contain a call to the scheduler.

1
firmware/asdf/build/README.md Normal file
View File

@ -0,0 +1 @@
This directory contains the files resulting from the build process

448
firmware/asdf/src/Arch/asdf_arch_atmega328p.c Normal file
View File

@ -0,0 +1,448 @@
// -*- mode: C; tab-width: 2 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_arch.c
//
// This file contains all the architecture dependent code, including register
// setup, I/O, timers, etc.
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
// Wiring Information:
// Chip: {Microcontroller type and version}
//
// Example:
// PIN NAME FUNCTION
// 14-19,9,10 PORTB COLUMN inputs (1 bit per column)
// 23-25 PORTC0-2 ROW outputs (row number)
// 27 PORTC4
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdint.h>
#include "asdf_arch.h"
static volatile uint8_t tick = 0;
static uint8_t data_polarity = 0; // normally positive polarity
static uint8_t strobe_polarity = 0; // normally positive polarity
// PROCEDURE: ISR for Timer 0 overflow
// INPUTS: none
// OUTPUTS:none
//
// DESCRIPTION: Occurs every 1 ms. Set tick flag, kick watchdog.
//
// SIDE EFFECTS:
//
// NOTES:
//
// SCOPE:
//
// COMPLEXITY:
//
ISR(TIMER0_COMPA_vect)
{
tick = 1;
}
// PROCEDURE: set_bit
// INPUTS: port: pointer to a (uint8) port
// bit: bit position to be set
// OUTPUTS: none
//
// DESCRIPTION: Give a port address and bit position, set the bit position.
//
// SIDE EFFECTS: See DESCRIPTION
//
// NOTES: Declared inline. Will only be inlined for functions in this module, so
// also declared static.
//
// SCOPE: private
//
// COMPLEXITY: 1
//
static inline void set_bit(volatile uint8_t *port, uint8_t bit)
{
*port |= (1 << bit);
}
// PROCEDURE: clear_bit
// INPUTS: port: pointer to a (uint8) port
// bit: bit position to be cleared
// OUTPUTS: none
//
// DESCRIPTION: Give a port address and bit position, clear the bit position.
//
// SIDE EFFECTS: See DESCRIPTION
//
// NOTES: Declared inline. Will only be inlined for functions in this module, so
// also declared static.
//
// SCOPE: private
//
// COMPLEXITY: 1
//
static inline void clear_bit(volatile uint8_t *port, uint8_t bit)
{
*port &= ~(1 << bit);
}
// PROCEDURE: arch_timer0_config
//
// INPUTS: bits: a 4 byte field containing the configuration values for the
// 8-bit timer0 A and B control registers, and the interrupt mask register.
//
// OUTPUTS: none
//
// DESCRIPTION: Takes a 4 byte value with settings for all the control
// registers for the 8-bit counter/timer (timer 0), and writes them all
// to the respective registers.
//
// SIDE EFFECTS: see above
//
// NOTES: Setting all the bits together, and writing all the registers from a
// single word permits more clear initialization of control fields that are
// spread across more than one word.
//
// COMPLEXITY: 1
//
// SCOPE: private
//
static void arch_timer0_config(uint32_t bits)
{
TCCR0B = 0; // first turn off timer.
TCCR0A = (bits >> TMR0A_POS) & 0xff;
TIMSK0 = (bits >> TMR0IMSK_POS) & 0xff;
TCCR0B = (bits >> TMR0B_POS) & 0xff; // Set the mode (and turn on timer) last
}
// PROCEDURE: arch_tick_timer_init
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Sets up 1ms tick timer.
//
// SIDE EFFECTS:
//
// NOTES: Set up Timer 0 in CTC mode for 1 ms overflow.
//
// SCOPE: private
//
// COMPLEXITY: 1
//
static void asdf_arch_tick_timer_init(void)
{
tick = 0;
// set compare register first, so timer can operate correctly as soon as it is
// enabled.
OCR0A = TICK_COUNT;
// operate in CTC mode to overflow at exactly 1 ms
// prescaler = 64 and output compare value is 250
arch_timer0_config(TIMER0_WFM_CTC | TIMER0_DIV64 | TIMER0_INT_ON_COMA);
}
// PROCEDURE: asdf_arch_tick
// INPUTS: none
// OUTPUTS: returns a 1 if the 1ms timer timed out, 0 otherwise
//
// DESCRIPTION: See Outputs.
//
// SIDE EFFECTS: Zeroes out the 1 ms timer flag.
//
// NOTES:
//
// SCOPE: public
//
// COMPLEXITY: 1
//
uint8_t asdf_arch_tick(void)
{
uint8_t retval = tick;
tick = 0;
return retval;
}
// PROCEDURE: asdf_arch_init_timers
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Sets up timer for 1 ms intervals
//
// SIDE EFFECTS: See DESCRIPTION
//
// SCOPE: private
//
// COMPLEXITY: 1
//
static void asdf_arch_init_clock(void)
{
CLKPR = (CLKPCE | SYSCLK_DIV1);
}
// PROCEDURE: asdf_arch_init_special_outputs
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Sets up special output lines for LED indicator(s), System RESET
// and SCREEN CLEAR, etc.
//
// SIDE EFFECTS: See DESCRIPTION
//
// SCOPE: private
//
// COMPLEXITY: 1
//
static void asdf_arch_init_special_outputs(void)
{
// initialize CAPS LED to OFF
clear_bit(&ASDF_CAPS_LED_PORT, ASDF_CAPS_LED_BIT);
set_bit(&ASDF_CAPS_LED_DDR, ASDF_CAPS_LED_BIT);
// initialize SCREEN_CLEAR output line to LOW (inactive)
clear_bit(&ASDF_SCREEN_CLEAR_PORT, ASDF_SCREEN_CLEAR_BIT);
set_bit(&ASDF_SCREEN_CLEAR_DDR, ASDF_SCREEN_CLEAR_BIT);
// initialize /SYS_RESET output line to HIGH (inactive)
set_bit(&ASDF_SYS_RESET_PORT, ASDF_SYS_RESET_BIT);
set_bit(&ASDF_SYS_RESET_DDR, ASDF_SYS_RESET_BIT);
// initialize /STROBE output to inactive. Must test before set/clear to avoid spurious strobe
if (strobe_polarity) {
set_bit(&ASDF_STROBE_PORT, ASDF_STROBE_BIT);
}
else {
clear_bit(&ASDF_STROBE_PORT, ASDF_STROBE_BIT);
}
set_bit(&ASDF_STROBE_DDR, ASDF_STROBE_BIT);
}
// PROCEDURE: asdf_arch_init_ascii_output
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Sets up output port for ASCII output
//
// SIDE EFFECTS: See DESCRIPTION
//
// SCOPE: private
//
// COMPLEXITY: 1
//
static void asdf_arch_init_ascii_output(void)
{
// set all outputs
ASDF_ASCII_PORT = 0;
ASDF_ASCII_DDR = ALL_OUTPUTS;
}
// PROCEDURE: asdf_arch_init_column_inputs
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: configure the shift register control lines. The MODE control is
// LOW for shift and HIGH for load. Shift or Load occurs when CLK goes high.
//
// SIDE EFFECTS: Cont
//
// SCOPE: private
//
// COMPLEXITY: 1
//
static void asdf_arch_init_column_control(void)
{
// COLCLK is output and initialized LOW
clear_bit(&ASDF_COLCLK_PORT, ASDF_COLCLK_BIT);
set_bit(&ASDF_COLCLK_DDR, ASDF_COLCLK_BIT);
// COLMODE is output and initialized HIGH
set_bit(&ASDF_COLMODE_PORT, ASDF_COLMODE_BIT);
set_bit(&ASDF_COLMODE_DDR, ASDF_COLMODE_BIT);
// COL is input, no weak pullup.
clear_bit(&ASDF_COL_DDR, ASDF_COL_BIT);
clear_bit(&ASDF_COL_PORT, ASDF_COL_BIT);
}
// PROCEDURE: asdf_arch_init_row_outputs
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Sets up output port to latch keyboard matrix row for scanning.
//
// SIDE EFFECTS: See DESCRIPTION
//
// SCOPE: private
//
// COMPLEXITY: 1
//
static void asdf_arch_init_row_outputs(void)
{
ASDF_ROW_PORT &= ~ASDF_ROW_MASK;
ASDF_ROW_DDR |= ASDF_ROW_MASK;
}
// PROCEDURE: asdf_arch_init
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: sets up all the hardware for the keyboard
//
// SIDE EFFECTS: see DESCRIPTION
//
// SCOPE: public
//
// COMPLEXITY: 1
//
void asdf_arch_init(void)
{
// disable interrupts:
cli();
// clear the 1ms timer flag;
tick = 0;
// set up timers for 1 msec intervals
asdf_arch_init_clock();
asdf_arch_tick_timer_init();
// set up ASCII output port
asdf_arch_init_ascii_output();
// initialize keyboard data and strobe to positive polairy
data_polarity = 0;
strobe_polarity = 0;
// set up strobe output
// set up indicator output
// set up RESET output
// set up CLEAR output
asdf_arch_init_special_outputs();
// set up row output port
asdf_arch_init_row_outputs();
// set up column control lines
asdf_arch_init_column_control();
// enable interrupts:
sei();
}
// PROCEDURE: asdf_arch_read_row
// INPUTS: (uint8_t) row: the row number to be scanned
// OUTPUTS: returns a word containing the active (pressed) columns
//
// DESCRIPTION: Outputs the argument to the ROW port, then reads the column port
// and returns the value. The value is a binary representation of the keys
// pressed within the row, with 1=pressed, 0=released.
//
// SIDE EFFECTS: Sets ROW output port.
//
// NOTES:
//
// 1) The keymap represents an unpressed key as a "0" and a pressed key as a
// "1". So, if a keypress pulls the column line low, then the reading of the
// physical bits must be inverted.
//
// SCOPE: public
//
// COMPLEXITY: 1
//
asdf_cols_t asdf_arch_read_row(uint8_t row)
{
asdf_cols_t cols = 0;
// first, output the new row value:
ASDF_ROW_PORT = (ASDF_ROW_PORT & ~ASDF_ROW_MASK) | row << ASDF_ROW_OFFSET;
// read in the columns. Set LOAD mode and pulse clock.
clear_bit(&ASDF_COLMODE_PORT, ASDF_COLMODE_BIT);
set_bit(&ASDF_COLCLK_PORT, ASDF_COLCLK_BIT);
clear_bit(&ASDF_COLCLK_PORT, ASDF_COLCLK_BIT);
// set back to SHIFT mode
set_bit(&ASDF_COLMODE_PORT, ASDF_COLMODE_BIT);
// After the load operation, the LSB is already at the output pin, so there
// will be one fewer read than clock pulse. Continue reading the bits until
// the leader bit is in the boundary position.
for (uint8_t i = 0; i < ASDF_NUM_COLS; i++) {
// invert the bits as they are read (see note 1)
cols |= (((~(ASDF_COL_PIN) >> ASDF_COL_BIT) & 1) << i);
set_bit(&ASDF_COLCLK_PORT, ASDF_COLCLK_BIT);
clear_bit(&ASDF_COLCLK_PORT, ASDF_COLCLK_BIT);
}
return cols;
}
// PROCEDURE: asdf_arch_send_code
// INPUTS: (keycode_t) code - the 7-bit ASCII code to be output by the keyboard
// OUTPUTS: none
//
// DESCRIPTION: Takes a character code and outputs the code on a parallel ASCII
// port, with a strobe. This routine could be replaced with UART, I2C, USB, or
// other output mechanism, of course.
//
// SIDE EFFECTS: See above.
//
// NOTES: The strobe is set by the ASDF_STROBE_LENGTH definition. The data
// output and strobe polarity are set by the static data_polarity and static
// strobe_polarity variables.
//
// SCOPE:
//
// COMPLEXITY:
//
void asdf_arch_send_code(asdf_keycode_t code)
{
ASDF_ASCII_PORT = (code ^ data_polarity);
// toggle strobe. Must test before setting to avoid spurious strobe
set_bit(&ASDF_STROBE_PINS, ASDF_STROBE_BIT);
_delay_us(ASDF_STROBE_LENGTH_US);
set_bit(&ASDF_STROBE_PINS, ASDF_STROBE_BIT);
}
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.
//

267
firmware/asdf/src/Arch/asdf_arch_atmega328p.h Normal file
View File

@ -0,0 +1,267 @@
// -*- mode: C; tab-width: 4 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_arch_atmega328p.h
//
// Contains architecture-specific definitions for the atmega 328p.
//
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
#if !defined(ASDF_ARCH_H)
#define ASDF_ARCH_H
#include <avr/io.h>
#include <avr/pgmspace.h>
#include "asdf.h"
// ASDF keyboard definitions:
#define ASDF_STROBE_LENGTH_US 10 // strobe length in microseconds
// Clock definitions:
#define SYSCLK_DIV1 0
#define SYSCLK_DIV2 (CLKPS0)
#define SYCCLK_DIV4 (CLKPS1)
#define SYSCLK_DIV8 (CLKPS1 | CLKPS0)
#define SYSCLK_DIV16 (CLKPS2)
#define SYSCLK_DIV32 (CLKPS2 | CLKPS0)
#define SYSCLK_DIV64 (CLKPS2 | CLKPS1)
#define SYSCLK_DIV128 (CLKPS2 | CLKPS1 | CLKPS0)
#define SYSCLK_DIV256 (CLKPS3)
// Define fields for register A, B, interrupt mask as 8-bit masks, and
// as masks offset into a combined config word
#define TMR0A_POS 0
#define TMR0B_POS 8
#define TMR0IMSK_POS 16
#define TMR0A (1L << TMR0A_POS)
#define TMR0B (1L << TMR0B_POS)
#define TMR0IMSK (1L << TMR0IMSK_POS)
#define TIMER0_COM_A_DISCONNECTED 0
#define TIMER0_COM_B_DISCONNECTED 0
#define TIMER0_WFM_CTC (TMR0A << WGM01)
#define TIMER0_DIV64 ((TMR0B << CS01) | (TMR0B << CS00))
#define TIMER0_INT_ON_COMA (TMR0IMSK << OCIE0A)
#define TIMER0_INT_ON_COMB (TMR0IMSK << OCIE0B)
#define TIMER0_INT_OV_ENABLE (TMR0IMSK << TOIE0)
// Macros for 16-bit timer 1. ATmega328P datasheet section 15, p. 108
//
// Define fields for Registers A, B, C, INT Mask registers as 8-bit
// masks, and as masks offset into a 32-bit combined config word.
//
// Macro definitions for individual registers are named TMR1A_*,
// TMR1B_*, and TMR1C_*.
//
// Macros for the one-step combined timer config functions are named
// TMR1_*.
//
//
// Examples:
// // Use TMR1B_* definition to set TCCR1B register
// TCCR1B |= TMR1B_DIV1;
//
// // Use TMR1_* definitions to configure timer with config function
// timer1_config(TMR1_WFM_CTC | TMR1_INT_ON_CMPA);
//
#define TMR1A_POS 0
#define TMR1B_POS 8
#define TMR1C_POS 16
#define TMR1IMSK_POS 24
#define TMR1A (1L << TMR1A_POS)
#define TMR1B (1L << TMR1B_POS)
#define TMR1C (1L << TMR1C_POS)
#define TMR1IMSK (1L << TMR1IMSK_POS)
// 16-bit timer reg A - Datasheet 17.11.1, p. 154
#define TMR1A_CMPA_CLR_MATCH_SET_BOTTOM (1 << COM1A1)
#define TMR1A_CMPB_CLR_MATCH_SET_BOTTOM (1 << COM1B1)
#define TMR1A_CMPC_CLR_MATCH_SET_BOTTOM (1 << COM1C1)
#define TMR1_CMPA_CLR_MATCH_SET_BOTTOM (TMR1A << COM1A1)
#define TMR1_CMPB_CLR_MATCH_SET_BOTTOM (TMR1A << COM1B1)
#define TMR1_CMPC_CLR_MATCH_SET_BOTTOM (TMR1A << COM1C1)
// 16-bit timer reg B - Datasheet 17.11.6, p. 156
#define TMR1B_IN_CAP_POS 0x40L
#define TMR1B_IN_CAP_NEG 0L
#define TMR1B_IN_CAP_NOISE_CANCEL 0x80L
// 16-bit timer reg C -- see datasheet, 17.11.9, p. 157
#define TMR1C_FOCA 0x80L
#define TMR1C_FOCB 0x40L
#define TMR1C_FOCC 0x20L
// 16-bit timer int mask -- see datasheet 17.11.33, p. 161.
#define TMR1IM_INT_CMP_MATCH_A (1L << OCIE1A)
#define TMR1IM_INT_CMP_MATCH_B (1L << OCIE1B)
#define TMR1IM_INT_CMP_MATCH_C (1L << OCIE1C)
// 16-bit timer all registers:
#define TMR1_CMPA_DISCONNECTED 0L
#define TMR1_CMPB_DISCONNECTED 0L
#define TMR1_CMPC_DISCONNECTED 0L
#define TMR1_INT_ON_CMPA (TMR1IM_INT_CMP_MATCH_A << TMR1IMSK_POS)
// 16-bit timer clock modes - see Datasheet table 17-6, p. 157
#define TMR1B_OFF 0
#define TMR1_OFF 0
#define TMR1B_DIV1 (0x01L << CS10)
#define TMR1B_DIV8 (0x02L << CS10)
#define TMR1B_DIV64 (0x03L << CS10)
#define TMR1B_DIV256 (0x04L << CS10)
#define TMR1B_DIV1024 (0x05L << CS10)
#define TMR1B_EXT_FALLING_EDGE (0x06L << CS10)
#define TMR1B_EXT_RISING_EDGE (0x07L << CS10)
#define TMR1B_CLK_MASK 0x07L
#define TMR1_DIV1 (TMR1B_DIV1 << TMR1B_POS)
#define TMR1_DIV8 (TMR1B_DIV8 << TMR1B_POS)
#define TMR1_DIV64 (TMR1B_DIV64 << TMR1B_POS)
#define TMR1_DIV256 (TMR1B_DIV256 << TMR1B_POS)
#define TMR1_DIV1024 (TMR1B_DIV1024 << TMR1B_POS)
#define TMR1_EXT_FALLING_EDGE (TMR1B_EXT_FALLING_EDGE << TMR1B_POS)
#define TMR1_EXT_RISING_EDGE (TMR1B_EXT_RISING_EDGE << TMR1B_POS)
#define TMR1B_EDGE_SEL_POSITIVE (1 << ICES1)
#define TMR1B_EDGE_SEL_NEGATIVE 0L
#define TMR1_EDGE_SEL_POSITIVE (TMR1B << ICES1)
#define TMR1_EDGE_SEL_NEGATIVE 0L
// 16-bit waveform modes (across reg A and B) Datasheet Table 17.2, p 145
#define TMR1_WFM_NORMAL 0L
#define TMR1_WFM_PWM_PC8 (TMR1A << WGM10) // PWM Phase Correct 8-bit
#define TMR1_WFM_PWM_PC9 (TMR1A << WGM11) // PWM Phase COrrect 9-bit
#define TMR1_WFM_PWM_PC10 ((TMR1A << WGM11) | (TMR1A << WGM10)) // PWM Phase Correct 10-bit
#define TMR1_WFM_CTC (TMR1B << WGM12) // CTC
#define TMR1_WFM_PWM_FAST8 ((TMR1B << WGM12) | (TMR1A << WGM10)) // PWM Fast 8-bit
#define TMR1_WFM_PWM_FAST9 ((TMR1B << WGM12) | (TMR1A << WGM11)) // PWM Fast 9-bit
#define TMR1_WFM_PWM_FAST10 \
((TMR1B << WGM12) | (TMR1A << WGM11) | (TMR1A << WGM10)) // PWM Fast 10-bit
#define TMR1_WFM_PWM_PFC_ICR (TMR1B << WGM13) // PWM Phase and Freq Correct, TpOP=ICR
#define TMR1_WFM_PWM_PFC_OCRA \
((TMR1B << WGM13) | (TMR1A << WGM10)) // PWM Phase and Freq Correct, TOP = OCRA
#define TMR1_WFM_PWM_PC_ICR ((TMR1B << WGM13) | (TMR1A << WGM11)) // PWM PhaseCorrect, TOP = ICR
#define TMR1_WFM_PWM_PC_OCRA \
((TMR1B << WGM13) | (TMR1A << WGM11) | (TMR1A << WGM12)) // PWM PhaseCorrect, TOP=OCRA
#define TMR1_WFM_CTC_ICR ((TMR1B << WGM13) | (TMR1B << WGM12)) // CTC, TOP = ICR
#define TMR1_WFM_PWM_FAST_ICR \
((TMR1B << WGM13) | (TMR1B << WGM12) | (TMR1A << WGM11)) // PWM Fast, TOP = ICR
#define TMR1_WFM_PWM_FAST_OCRA \
((TMR1B << WGM13) | (TMR1B << WGM12) | (TMR1A << WGM11) \
| (TMR1A << WGM10)) // PWM Fast, TOP = OCRA
// I/O port definitions:
#define PIN_INPUT 0
#define PIN_OUTPUT 1
#define ALL_INPUTS 0
#define ALL_OUTPUTS 0xff
#define ASDF_ROW_PORT PORTC
#define ASDF_ROW_DDR DDRC
#define ASDF_ROW_MASK 0x07
#define ASDF_ROW_OFFSET 0
#define ASDF_COL_PORT PORTB
#define ASDF_COL_PIN PINB
#define ASDF_COL_DDR DDRB
#define ASDF_COL_BIT 0
#define ASDF_COL_PULLUPS 0 // disable weak pullup
#define ASDF_COLCLK_PORT PORTB
#define ASDF_COLCLK_PINS PINB
#define ASDF_COLCLK_DDR DDRB
#define ASDF_COLCLK_BIT 2
#define ASDF_COLMODE_PORT PORTB
#define ASDF_COLMODE_PINS PINB
#define ASDF_COLMODE_DDR DDRB
#define ASDF_COLMODE_BIT 1
#define ASDF_ASCII_PORT PORTD
#define ASDF_ASCII_DDR DDRD
#define ASDF_CAPS_LED_PORT PORTC
#define ASDF_CAPS_LED_DDR DDRC
#define ASDF_CAPS_LED_BIT 3
#define ASDF_SCREEN_CLEAR_PORT PORTC
#define ASDF_SCREEN_CLEAR_DDR DDRC
#define ASDF_SCREEN_CLEAR_BIT 4
#define ASDF_SYS_RESET_PORT PORTC
#define ASDF_SYS_RESET_DDR DDRC
#define ASDF_SYS_RESET_BIT 5
#define ASDF_STROBE_PORT PORTB
#define ASDF_STROBE_PINS PINB
#define ASDF_STROBE_DDR DDRB
#define ASDF_STROBE_BIT 6
#define FUSE_INTERNAL_8MHZ_OSC_0MS (FUSE_CKSEL0 | FUSE_CKSEL2 | FUSE_CKSEL3 | FUSE_SUT0 | FUSE_SUT1)
#define FUSE_INTERNAL_8MHZ_OSC_4MS (FUSE_CKSEL0 | FUSE_CKSEL2 | FUSE_CKSEL3 | FUSE_SUT1)
#define FUSE_INTERNAL_8MHZ_OSC_65MS (FUSE_CKSEL0 | FUSE_CKSEL2 | FUSE_CKSEL3 | FUSE_SUT0)
#define FLASH PROGMEM
// not implemented with do-while(0) because this is a function call that returns
// a value, and parameters are expanded inside the parameter list, so this will
// be valid when substituting for function-like syntax.
#define FLASH_READ (a) pgm_read_byte((a))
#define FLASH_READ_MATRIX_ELEMENT(matrix, row, col) pgm_read_byte(&((matrix)[(row)][(col)]))
// For 1 ms tick, (8000000 / 64(prescale)) / 1000(usec) - 1 = 124
#define TICK_COUNT 124
// PROCEDURE: asdf_arch_read_row
// INPUTS: (uint8_t) row: the row number to be scanned
// OUTPUTS: returns a word containing the active (pressed) columns
// DESCRIPTION: Outputs the argument to the ROW port, then reads the column port
// and returns the value. The value is a binary representation of the keys
// pressed within the row, with 1=pressed, 0=released.
asdf_cols_t asdf_arch_read_row(uint8_t row);
// PROCEDURE: asdf_arch_tick
// INPUTS: none
// OUTPUTS: returns a 1 if the 1ms timer timed out, 0 otherwise
uint8_t asdf_arch_tick(void);
// PROCEDURE: asdf_arch_send_code
// INPUTS: (keycode_t) code - the code to be output by the keyboard
// OUTPUTS: none
// DESCRIPTION: Takes a character code and outputs the code on a parallel ASCII
// port, with a strobe. This routine could be replaced with UART, I2C, USB, or
// other output mechanism, of course.
void asdf_arch_send_code(asdf_keycode_t code);
// PROCEDURE: asdf_arch_init
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: sets up all the hardware for the keyboard
void asdf_arch_init(void);
#endif /* !defined (ASDF_ARCH_H) */
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

43
firmware/asdf/src/Arch/asdf_arch_test.h Normal file
View File

@ -0,0 +1,43 @@
// -*- mode: C; tab-width: 4 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_arch_test.h
//
// Architecture-dependent definitions for the unit-testing ASDF software.
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
#if !defined (ASDF_ARCH_H)
#define ASDF_ARCH_H
#define FLASH
#define FLASH_READ (a) (*(a))
#define FLASH_READ_MATRIX_ELEMENT(mat,row,col) (mat)[(row)][(col)]
void asdf_arch_init(void);
void asdf_arch_tick(void);
uint8_t asdf_arch_read_row(uint8_t row);
#endif // !defined (ASDF_ARCH_H)
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

128
firmware/asdf/src/Keymaps/asdf_keymaps_ascii.h Normal file
View File

@ -0,0 +1,128 @@
// -*- mode: C; tab-width: 4 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_keymaps.h
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
#if !defined(ASDF_KEYMAPS_H)
#define ASDF_KEYMAPS_H
#include "asdf.h"
#include "asdf_ascii.h"
#include "asdf_modifiers.h"
#define ASCII_PLAIN_MAP \
{ \
{ ACTION_NOTHING, ACTION_SHIFT, ACTION_SHIFT, ACTION_NOTHING, \
ACTION_NOTHING, ASCII_ESC, ACTION_CTRL, ASCII_BACKSLASH }, \
{ ASCII_DEL, 'p', ';', '/', ASCII_SPACE, 'z', 'a', 'q' }, \
{ ACTION_BREAK, ASCII_COMMA, 'm', 'n', 'b', 'v', 'c', 'x' }, \
{ ACTION_NOTHING, 'k', 'j', 'h', 'g', 'f', 'd', 's' }, \
{ ACTION_CLEAR, 'i', 'u', 'y', 't', 'r', 'e', 'w' }, { ACTION_REPEAT, \
ACTION_HERE_IS, \
ACTION_SHIFT_LOCK, \
ASCII_CR, \
ASCII_LF, \
'o', \
'l', \
ASCII_PERIOD }, \
{ ASCII_TILDE, ASCII_RT_SQUARE_BRACE, ASCII_LT_SQUARE_BRACE, '-', ':', '0', '9', '8' }, \
{ \
ASCII_AT, '7', '6', '5', '4', '3', '2', '1' \
} \
}
#define ASCII_CAPS_MAP \
{ \
{ ACTION_NOTHING, ACTION_SHIFT, ACTION_SHIFT, ACTION_NOTHING, \
ACTION_NOTHING, ASCII_ESC, ACTION_CTRL, ASCII_BACKSLASH }, \
{ ASCII_DEL, 'P', ';', '/', ASCII_SPACE, 'Z', 'A', 'Q' }, \
{ ACTION_BREAK, ASCII_COMMA, 'M', 'N', 'B', 'V', 'C', 'X' }, \
{ ACTION_NOTHING, 'K', 'J', 'H', 'G', 'F', 'D', 'S' }, \
{ ACTION_CLEAR, 'I', 'U', 'Y', 'T', 'R', 'E', 'W' }, { ACTION_REPEAT, \
ACTION_HERE_IS, \
ACTION_SHIFT_LOCK, \
ASCII_CR, \
ASCII_LF, \
'O', \
'L', \
ASCII_PERIOD }, \
{ ASCII_TILDE, ASCII_RT_SQUARE_BRACE, ASCII_LT_SQUARE_BRACE, '-', ':', '0', '9', '8' }, \
{ \
ASCII_AT, '7', '6', '5', '4', '3', '2', '1' \
} \
}
#define ASCII_SHIFT_MAP \
{ \
{ ACTION_NOTHING, ACTION_SHIFT, ACTION_SHIFT, ACTION_NOTHING, \
ACTION_NOTHING, ASCII_ESC, ACTION_CTRL, ASCII_VERT_BAR }, \
{ ASCII_DEL, 'P', '+', '?', ASCII_SPACE, 'Z', 'A', 'Q' }, \
{ ACTION_BREAK, '>', 'M', 'N', 'B', 'V', 'C', 'X' }, \
{ ACTION_NOTHING, 'K', 'J', 'H', 'G', 'F', 'D', 'S' }, \
{ ACTION_CLEAR, 'I', 'U', 'Y', 'T', 'R', 'E', 'W' }, \
{ ACTION_REPEAT, ACTION_HERE_IS, ACTION_SHIFT_LOCK, ASCII_CR, ASCII_LF, 'O', 'L', '<' }, \
{ ASCII_TILDE, ASCII_RT_CURLY_BRACE, ASCII_LT_CURLY_BRACE, '=', '*', \
'0', ASCII_RT_PAREN, ASCII_LT_PAREN }, \
{ \
ASCII_GRAVE_ACCENT, ASCII_SINGLE_QUOTE, '&', '%', '$', '#', ASCII_DOUBLE_QUOTE, '!' \
} \
}
#define ASCII_CTRL_MAP \
{ \
{ ACTION_NOTHING, ACTION_SHIFT, ACTION_SHIFT, ACTION_NOTHING, \
ACTION_NOTHING, ASCII_ESC, ACTION_CTRL, 0x1c }, \
{ ACTION_NOTHING, ASCII_CTRL_P, ACTION_NOTHING, ACTION_NOTHING, \
ASCII_SPACE, ASCII_CTRL_Z, ASCII_CTRL_A, ASCII_CTRL_Q }, \
{ ACTION_BREAK, ASCII_COMMA, ASCII_CTRL_M, ASCII_CTRL_N, \
ASCII_CTRL_B, ASCII_CTRL_V, ASCII_CTRL_C, ASCII_CTRL_X }, \
{ ACTION_CLEAR, ASCII_CTRL_I, ASCII_CTRL_U, ASCII_CTRL_Y, \
ASCII_CTRL_T, ASCII_CTRL_R, ASCII_CTRL_E, ASCII_CTRL_W }, \
{ ACTION_REPEAT, ACTION_HERE_IS, ACTION_SHIFT_LOCK, ASCII_CR, \
ASCII_LF, ASCII_CTRL_O, ASCII_CTRL_L, ACTION_NOTHING }, \
{ ACTION_NOTHING, 0x1d, ASCII_ESC, ACTION_NOTHING, \
ACTION_NOTHING, ACTION_FN_1, ACTION_FN_9, ACTION_FN_8 }, \
{ \
ACTION_NOTHING, ACTION_FN_7, ACTION_FN_6, ACTION_FN_5, ACTION_FN_4, ACTION_FN_3, \
ACTION_FN_2, ACTION_FN_2 \
} \
}
// PROCEDURE: asdf_keymaps_init
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Assigns the keymaps to the indices specified by the modifier
// index, to avoid hard-coding constant index values.
void asdf_keymaps_init(void);
// PROCEDURE: asdf_keymaps_get_code
// INPUTS: row, col: row and column of key that has been pressed
// modifiers_index: index into the keymap array, based on modifier state
// OUTPUTS: returns a key code.
// DESCRIPTION: Given a key row and column, and an index based on modifier
// state, return the appropriate keycode.
asdf_keycode_t asdf_keymaps_get_code(uint8_t row, uint8_t col, uint8_t modifier_index);
#endif /* !defined (ASDF_KEYMAPS_H) */
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

131
firmware/asdf/src/Keymaps/asdf_keymaps_test.h Normal file
View File

@ -0,0 +1,131 @@
// -*- mode: C; tab-width: 4 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_keymaps.h
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
// While there is nothing preventing a standard keyboard from having both a
// "Shift Lock" key and a "Caps Lock" key, usually only one will be present. For
// testing, both must be present to test their functionality.
#if !defined(ASDF_KEYMAPS_H)
#define ASDF_KEYMAPS_H
#include "asdf.h"
#include "asdf_ascii.h"
#include "asdf_modifiers.h"
#define ASCII_PLAIN_MAP \
{ \
{ ACTION_CAPS, ACTION_SHIFT, ACTION_SHIFT, ACTION_NOTHING, \
ACTION_NOTHING, ASCII_ESC, ACTION_CTRL, ASCII_BACKSLASH }, \
{ ACTION_NOTHING, 'p', ';', '/', ASCII_SPACE, 'z', 'a', 'q' }, \
{ ACTION_BREAK, ASCII_COMMA, 'm', 'n', 'b', 'v', 'c', 'x' }, \
{ ACTION_NOTHING, 'k', 'j', 'h', 'g', 'f', 'd', 's' }, \
{ ACTION_CLEAR, 'i', 'u', 'y', 't', 'r', 'e', 'w' }, { ACTION_REPEAT, \
ACTION_HERE_IS, \
ACTION_SHIFT_LOCK, \
ASCII_CR, \
ASCII_LF, \
'o', \
'l', \
ASCII_PERIOD }, \
{ ASCII_TILDE, ASCII_RT_SQUARE_BRACE, ASCII_LT_SQUARE_BRACE, '-', ':', '0', '9', '8' }, \
{ \
ACTION_NOTHING, '7', '6', '5', '4', '3', '2', '1' \
} \
}
#define ASCII_CAPS_MAP \
{ \
{ ACTION_NOTHING, ACTION_SHIFT, ACTION_SHIFT, ACTION_NOTHING, \
ACTION_NOTHING, ASCII_ESC, ACTION_CTRL, ASCII_BACKSLASH }, \
{ ACTION_NOTHING, 'P', ';', '/', ASCII_SPACE, 'Z', 'A', 'Q' }, \
{ ACTION_BREAK, ASCII_COMMA, 'M', 'N', 'B', 'V', 'C', 'X' }, \
{ ACTION_NOTHING, 'K', 'J', 'H', 'G', 'F', 'D', 'S' }, \
{ ACTION_CLEAR, 'I', 'U', 'Y', 'T', 'R', 'E', 'W' }, { ACTION_REPEAT, \
ACTION_HERE_IS, \
ACTION_SHIFT_LOCK, \
ASCII_CR, \
ASCII_LF, \
'O', \
'L', \
ASCII_PERIOD }, \
{ ASCII_TILDE, ASCII_RT_SQUARE_BRACE, ASCII_LT_SQUARE_BRACE, '-', ':', '0', '9', '8' }, \
{ \
ACTION_NOTHING, '7', '6', '5', '4', '3', '2', '1' \
} \
}
#define ASCII_SHIFT_MAP \
{ \
{ ACTION_NOTHING, ACTION_SHIFT, ACTION_SHIFT, ACTION_NOTHING, \
ACTION_NOTHING, ASCII_ESC, ACTION_CTRL, ASCII_VERT_BAR }, \
{ ACTION_NOTHING, 'P', '+', '?', ASCII_SPACE, 'Z', 'A', 'Q' }, \
{ ACTION_BREAK, '>', 'M', 'N', 'B', 'V', 'C', 'X' }, \
{ ACTION_NOTHING, 'K', 'J', 'H', 'G', 'F', 'D', 'S' }, \
{ ACTION_CLEAR, 'I', 'U', 'Y', 'T', 'R', 'E', 'W' }, \
{ ACTION_REPEAT, ACTION_HERE_IS, ACTION_SHIFT_LOCK, ASCII_CR, ASCII_LF, 'O', 'L', '<' }, \
{ ASCII_TILDE, ASCII_RT_CURLY_BRACE, ASCII_LT_CURLY_BRACE, '=', '*', \
'0', ASCII_RT_PAREN, ASCII_LT_PAREN }, \
{ \
ACTION_NOTHING, ASCII_SINGLE_QUOTE, '&', '%', '$', '#', ASCII_DOUBLE_QUOTE, '!' \
} \
}
#define ASCII_CTRL_MAP \
{ \
{ ACTION_NOTHING, ACTION_SHIFT, ACTION_SHIFT, ACTION_NOTHING, \
ACTION_NOTHING, ASCII_ESC, ACTION_CTRL, 0x1c }, \
{ ACTION_NOTHING, ASCII_CTRL_P, ACTION_NOTHING, ACTION_NOTHING, \
ASCII_SPACE, ASCII_CTRL_Z, ASCII_CTRL_A, ASCII_CTRL_Q }, \
{ ACTION_BREAK, ASCII_COMMA, ASCII_CTRL_M, ASCII_CTRL_N, \
ASCII_CTRL_B, ASCII_CTRL_V, ASCII_CTRL_C, ASCII_CTRL_X }, \
{ ACTION_CLEAR, ASCII_CTRL_I, ASCII_CTRL_U, ASCII_CTRL_Y, \
ASCII_CTRL_T, ASCII_CTRL_R, ASCII_CTRL_E, ASCII_CTRL_W }, \
{ ACTION_REPEAT, ACTION_HERE_IS, ACTION_SHIFT_LOCK, ASCII_CR, \
ASCII_LF, ASCII_CTRL_O, ASCII_CTRL_L, ACTION_NOTHING }, \
{ ACTION_NOTHING, 0x1d, ASCII_ESC, ACTION_NOTHING, \
ACTION_NOTHING, ACTION_FN_1, ACTION_FN_9, ACTION_FN_8 }, \
{ \
ACTION_NOTHING, ACTION_FN_7, ACTION_FN_6, ACTION_FN_5, ACTION_FN_4, ACTION_FN_3, \
ACTION_FN_2, ACTION_FN_2 \
} \
}
// PROCEDURE: asdf_keymaps_init
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Assigns the keymaps to the indices specified by the modifier
// index, to avoid hard-coding constant index values.
void asdf_keymaps_init(void);
// PROCEDURE: asdf_keymaps_get_code
// INPUTS: row, col: row and column of key that has been pressed
// modifiers_index: index into the keymap array, based on modifier state
// OUTPUTS: returns a key code.
// DESCRIPTION: Given a key row and column, and an index based on modifier
// state, return the appropriate keycode.
asdf_keycode_t asdf_keymaps_get_code(uint8_t row, uint8_t col, uint8_t modifier_index);
#endif /* !defined (ASDF_KEYMAPS_H) */
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

21
firmware/asdf/src/Makefile Normal file
View File

@ -0,0 +1,21 @@
ARCH ?= atmega328p
KEYMAP ?= ascii
BUILD_DIR = ../build
all: app
app:
make -f Makefile.app
test:
make -f Makefile.test
clean:
make -f Makefile.app clean
make -f Makefile.test clean
cleanall:
make -f Makefile.app cleanall
make -f Makefile.test cleanall

157
firmware/asdf/src/Makefile.app Normal file
View File

@ -0,0 +1,157 @@
ARCH ?= atmega328p
KEYMAP ?= ascii
ARCH_TOKEN = _Arch_$(ARCH)
TARGET = asdf
TEST_DIR = ../test
UNITY_DIR = $(TEST_DIR)/unity
BUILD_DIR = ../build
DEP_DIR := ./.deps
TARGET_BIN := $(BUILD_DIR)/$(TARGET).elf
TARGET_HEX := $(BUILD_DIR)/$(TARGET).hex
TARGET_MAP := $(BUILD_DIR)/$(TARGET).map
UNITY_SCRIPTS = $(UNITY_DIR)/auto
ARCH_DIR = Arch
KEYMAPS_DIR = Keymaps
VERSION =
RELEASE=
SIZE_COMMAND = avr-size
CLOCK = 8000000L
CLEAN_FILES =
CLEANALL_FILES =
CC = avr-gcc
CFLAGS = -std=c99
CFLAGS += -Wall
CFLAGS += -funsigned-char
CFLAGS += -funsigned-bitfields
CFLAGS += -ffunction-sections
CFLAGS += -fdata-sections
CFLAGS += -fpack-struct
CFLAGS += -fshort-enums
CFLAGS += -O2
CFLAGS += -Wall
CFLAGS += -Wextra
CFLAGS += -Wpointer-arith
CFLAGS += -Wcast-align
CFLAGS += -Wwrite-strings
CFLAGS += -Wswitch-default
CFLAGS += -Wunreachable-code
CFLAGS += -Winit-self
CFLAGS += -Wmissing-field-initializers
CFLAGS += -Wno-unknown-pragmas
CFLAGS += -Wstrict-prototypes
CFLAGS += -Wundef
CFLAGS += -Wold-style-definition
CFLAGS += -mmcu=$(ARCH)
CFLAGS += -DF_CPU=$(CLOCK)
LDFLAGS = -Wl,-Map=$(TARGET_MAP)
LDFLAGS += -Wl,--start-group
LDFLAGS += -Wl,-lm
LDFLAGS += -Wl,--end-group
LDFLAGS += -Wl,--gc-sections
DEPFLAGS = -MT $@ -MMD -MP -MF $(DEPDIR)/$*.d
MAKEDEPEND = $(CPP) $(DEPFLAGS) $(CPPFLAGS) $< \
| sed -n 's,^\# *[0-9][0-9]* *"\([^"<]*\)".*,$@: \1\n\1:,p' \
| sort -u > $*.d
SRC_FILES = main.c asdf.c asdf_modifiers.c asdf_repeat.c asdf_keymaps.c asdf_buffer.c asdf_arch.c
OBJ_FILES := $(SRC_FILES:.c=.o)
DEP_FILES := $(SRC_FILES:%.c=$(DEP_DIR)/%.d)
MAP_FILE = $(TARGET).map
CLEAN_FILES += $(MAP_FILE)
CLEAN_FILES += $(TARGET_BIN)
CLEAN_FILES += $(TARGET_MAP)
CLEANALL_FILES += $(TARGET_HEX)
MAKEFILES = Makefile
GENERATED_FILES = conventions.h machine.h
ALL_FILES = $(MAKEFILES) $(SRC_FILES) $(TXTFILES) $(GENERATED_FILES)
.SUFFIXES:
.SUFFIXES: .c .o .bin .hex
all: $(TARGET_HEX)
%.d : %.c $(DEP_DIR)/%.d | $(DEP_DIR)
@$(MAKEDEPEND)
$(DEP_DIR): ; @mkdir -p $@
$(DEPFILES):
include $(wildcard $(DEPFILES))
%.o: %.c $(DEP_DIR)/%.d | $(DEP_DIR)
$(CC) -c $(CPPFLAGS) $(CFLAGS) $(DEPFLAGS) $<
asdf_keymaps.h: $(KEYMAPS_DIR)/asdf_keymaps_$(KEYMAP).h $(KEYMAP_H_TOKEN)
cp $< $@
GENERATED_FILES += asdf_keymaps.h
asdf_arch.c: $(ARCH_DIR)/asdf_arch_$(ARCH).c $(ARCH_C_TOKEN)
cp $< $@
GENERATED_FILES += asdf_arch.c
asdf_arch.h: $(ARCH_DIR)/asdf_arch_$(ARCH).h $(ARCH_H_TOKEN)
cp $< $@
GENERATED_FILES += asdf_arch.h
$(ARCH_H_TOKEN):
touch $@
$(ARCH_C_TOKEN):
touch $@
$(KEYMAP_H_TOKEN):
touch $@
size:
$(SIZE_COMMAND) $(TARGET_BIN)
$(TARGET_HEX): $(TARGET_BIN)
avr-objcopy -j .text -j .data -j .fuses -O ihex $< $@
$(TARGET_BIN): $(OBJ_FILES)
$(CC) $(CFLAGS) -o $@ $(LDFLAGS) $^
$(SIZE_COMMAND) $(TARGET_BIN)
asdf_keymaps.o: asdf_keymaps.c asdf.h asdf_ascii.h asdf_modifiers.h asdf_arch.h asdf_keymaps.h
main.o: main.c asdf.h asdf_arch.h
asdf.o: asdf.c asdf.h asdf_arch.h asdf_keymaps.h asdf_config.h
asdf_repeat.o: asdf_repeat.c asdf_repeat.h asdf_config.h
asdf_buffer.o: asdf_buffer.c asdf.h asdf_config.h
asdf_modifiers.o: asdf_modifiers.c asdf_modifiers.h
tags: $(SRC_FILES)
etags $(SRC_FILES)
CLEAN_FILES += $(TEST_BUILD_FILES) _Arch_* *.o
CLEAN_FILES += ~* *\#
CLEANALL_FILES += $(GENERATED_FILES) $(TARGET_BUILD_FILES) $(TEST_BUILD_FILES)
.PHONY: clean
clean:
rm -f $(CLEAN_FILES)
.PHONY: cleanall
cleanall:
rm -f $(CLEAN_FILES) $(CLEANALL_FILES)

21
firmware/asdf/src/Makefile.deps Normal file
View File

@ -0,0 +1,21 @@
# -*- makefile -*-
DEP_DIR := .deps
DEPFLAGS = -MT $@ -MMD -MP -MF $(DEPDIR)/$*.d
MAKEDEPEND = $(CPP) $(DEPFLAGS) $(CPPFLAGS) $< \
| sed -n 's,^\# *[0-9][0-9]* *"\([^"<]*\)".*,$@: \1\n\1:,p' \
| sort -u > $*.d
%.d : %.c $(DEP_DIR)/%.d | $(DEPDIR)
@$(MAKEDEPEND)
$(DEP_DIR): ; @mkdir -p $@
DEPFILES := $(SRC_FILES:%.c=$(DEP_DIR)/%.d)
$(DEPFILES):
include $(wildcard $(DEPFILES))

155
firmware/asdf/src/Makefile.test Normal file
View File

@ -0,0 +1,155 @@
ARCH = test
ARCH = test
KEYMAP = test
ARCH_TOKEN = _Arch_$(ARCH)
TEST_DIR = ../test
UNITY_DIR = $(TEST_DIR)/unity
BUILD_DIR = ../build
UNITY_SCRIPTS = $(UNITY_DIR)/auto
ARCH_DIR = ./Arch
KEYMAPS_DIR = ./Keymaps
CC = gcc
VERSION =
RELEASE=
CLEAN_FILES =
CLEANALL_FILES =
CFLAGS=-std=c99
CFLAGS += -Wall
CFLAGS += -Wextra
CFLAGS += -Wpointer-arith
CFLAGS += -Wcast-align
CFLAGS += -Wwrite-strings
CFLAGS += -Wswitch-default
CFLAGS += -Wunreachable-code
CFLAGS += -Winit-self
CFLAGS += -Wmissing-field-initializers
CFLAGS += -Wno-unknown-pragmas
CFLAGS += -Wstrict-prototypes
CFLAGS += -Wundef
CFLAGS += -Wold-style-definition
SRC_FILES = main.c asdf.c asdf_modifiers.c asdf_repeat.c asdf_keymaps.c asdf_buffer.c asdf_arch.c
OBJ_FILES = $(SRC_FILES:.c=.o)
ARCH_FILES = asdf_arch.c asdf_arch.h
CLEAN_FILES += ARCH_FILES
TESTS = repeat modifiers keymaps interface keyscan
TEST1 = asdf_repeat
TEST1_SRC = $(TEST_DIR)/test_$(TEST1).c
TEST1_DEPS = ./$(TEST1).c $(UNITY_DIR)/unity.c
TEST1_BUILD = $(BUILD_DIR)/test_$(TEST1)
TEST2 = asdf_modifiers
TEST2_SRC = $(TEST_DIR)/test_$(TEST2).c
TEST2_DEPS = ./$(TEST2).c $(UNITY_DIR)/unity.c
TEST2_BUILD = $(BUILD_DIR)/test_$(TEST2)
TEST3 = asdf_keymaps
TEST3_SRC = $(TEST_DIR)/test_$(TEST3).c
TEST3_DEPS = ./$(TEST3).c $(UNITY_DIR)/unity.c
TEST3_BUILD = $(BUILD_DIR)/test_$(TEST3)
TEST4 = asdf_buffer
TEST4_SRC = $(TEST_DIR)/test_$(TEST4).c
TEST4_DEPS = ./$(TEST4).c $(UNITY_DIR)/unity.c
TEST4_BUILD = $(BUILD_DIR)/test_$(TEST4)
TEST5 = asdf
TEST5_SRC = $(TEST_DIR)/test_$(TEST5).c
TEST5_DEPS = ./$(TEST5).c $(UNITY_DIR)/unity.c ./$(TEST1).c $(TEST2).c $(TEST3).c $(TEST4).c
TEST5_BUILD = $(BUILD_DIR)/test_$(TEST5)
.SUFFIXES:
.SUFFIXES: .c .o .bin .hex
%.o: %.c
$(TARGET_CC) -c $(TARGET_CPPFLAGS) $(TARGET_CFLAGS) $<
all: test
asdf_keymaps.h: Keymaps/asdf_keymaps_$(KEYMAP).h
cp $< $@
GENERATED_FILES += asdf_keymaps.h
asdf_arch.c: $(ARCH_DIR)/asdf_arch_$(ARCH).c _Arch_$(ARCH)
cp $< $@
GENERATED_FILES += asdf_arch.c
asdf_arch.h: $(ARCH_DIR)/asdf_arch_$(ARCH).h _Arch_$(ARCH)
cp $< $@
GENERATED_FILES += asdf_arch.h
$(ARCH_TOKEN):
touch $(ARCH_TOKEN)
asdf_keymaps.c: asdf.h asdf_ascii.h asdf_modifiers.h asdf_arch.h asdf_keymaps.h
tags: $(SRC_FILES)
etags $(SRC_FILES)
.PHONY: test
test: test1 test2 test3 test4 test5
.PHONY: test1
test1: $(TEST1_BUILD)
$(TEST1_BUILD)
.PHONY: test2
test2: $(TEST2_BUILD)
$(TEST2_BUILD)
.PHONY: test3
test3: $(TEST3_BUILD)
$(TEST3_BUILD)
.PHONY: test4
test4: $(TEST4_BUILD)
$(TEST4_BUILD)
.PHONY: test5
test5: $(TEST5_BUILD)
$(TEST5_BUILD)
$(TEST1_BUILD): $(TEST1_SRC) $(TEST1_DEPS)
$(CC) -o $@ -I. -I$(TEST_DIR) -I$(UNITY_DIR) $(CFLAGS) $(TEST1_SRC) $(TEST1_DEPS)
$(TEST2_BUILD): $(TEST2_SRC) $(TEST2_DEPS)
$(CC) -o $@ -I. -I$(TEST_DIR) -I$(UNITY_DIR) $(CFLAGS) $(TEST2_SRC) $(TEST2_DEPS)
$(TEST3_BUILD): $(TEST3_SRC) $(TEST3_DEPS)
$(CC) -o $@ -I. -I$(TEST_DIR) -I$(UNITY_DIR) $(CFLAGS) $(TEST3_SRC) $(TEST3_DEPS)
$(TEST4_BUILD): $(TEST4_SRC) $(TEST4_DEPS)
$(CC) -o $@ -I. -I$(TEST_DIR) -I$(UNITY_DIR) $(CFLAGS) $(TEST4_SRC) $(TEST4_DEPS)
$(TEST5_BUILD): $(TEST5_SRC) $(TEST5_DEPS)
$(CC) -o $@ -I. -I$(TEST_DIR) -I$(UNITY_DIR) $(CFLAGS) $(TEST5_SRC) $(TEST5_DEPS)
TEST_BUILD_FILES += $(TEST1_BUILD) $(TEST2_BUILD) $(TEST3_BUILD) $(TEST4_BUILD) $(TEST5_BUILD)
CLEAN_FILES += $(TEST_BUILD_FILES) _Arch_* *.o
CLEAN_FILES += ~* *\#
CLEANALL_FILES += $(GENERATED_FILES) $(TARGET_BUILD_FILES) $(TEST_BUILD_FILES)
.PHONY: clean
clean:
rm -f $(CLEAN_FILES)
.PHONY: cleanall
cleanall:
rm -f $(CLEAN_FILES) $(CLEANALL_FILES)
include Makefile.deps

125
firmware/asdf/src/Templates/template.c Normal file
View File

@ -0,0 +1,125 @@
// -*- mode: C; tab-width: 2 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// <FIXME-filename>.c
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
//
//iring Information:
// Chip: {Microcontroller type and version}
//
// Example:
// PIN NAME FUNCTION
// 3 AN1 ADC INPUT: Line sense analog input
//
// 6 A4 INPUT: (T0CK) COUNT DOWN from quadrature decoder.
// configured to count on rising edge, synced with xtal
//
//
// Headers
//
#include <version.h>
//
// Global Variable declarations: Use very sparingly. Used for communication
// with ISR's. Exceptions should be documented.
//
// Examples:
// run_clock_thread (global uns 8) when this is set to TRUE (by the
// clock_tick() ISR every 20 ms), the main loop performs certain
// actions, and resets the value to FALSE (see main loop comments)
//
uint8 send_count = FALSE;
//
// ISR routines
//
// PROCEDURE:
// INPUTS:
// OUTPUTS:
//
// DESCRIPTION:
//
// SIDE EFFECTS:
//
// NOTES:
//
// COMPLEXITY:
//
//
// Regular functions
//
// PROCEDURE:
// INPUTS:
// OUTPUTS:
//
// DESCRIPTION:
//
// SIDE EFFECTS:
//
// NOTES:
//
// SCOPE:
//
// COMPLEXITY:
//
// PROCEDURE: main()
//
// Main program loop; invoked at processor startup.
//
main()
{
// INITIALIZATION SECTION
cold_start:
// re-initialize variables and re-enter control loop, when the "R" command
// is received
warm_start:
// END OF INITIALIZATION SECTION
// Main Section:
}
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

41
firmware/asdf/src/Templates/template.h Normal file
View File

@ -0,0 +1,41 @@
// -*- mode: C; tab-width: 4 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// <FIXME-filename>.h
//
// Copyright 2019 David Fenyes
// 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 3 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 <https://www.gnu.org/licenses/>.
//
#if !defined (FILENAME_H)
#define FILENAME_H
//
// Headers
//
//
// Device and peripheral definitions, comments should include use of devices.
// Please
//
#endif /* !defined (FILENAME_H) */
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

46
firmware/asdf/src/_clang-format Normal file
View File

@ -0,0 +1,46 @@
---
BasedOnStyle: Mozilla
AlignAfterOpenBracket: Align
AlignOperands: 'true'
AlignTrailingComments: 'true'
AllowAllParametersOfDeclarationOnNextLine: 'false'
AllowShortBlocksOnASingleLine: 'false'
AllowShortCaseLabelsOnASingleLine: 'true'
AllowShortFunctionsOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: 'false'
AllowShortLoopsOnASingleLine: 'true'
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: 'true'
BinPackArguments: 'true'
BinPackParameters: 'true'
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeBraces: Stroustrup
ColumnLimit: '100'
ConstructorInitializerIndentWidth: '2'
ContinuationIndentWidth: '2'
DerivePointerAlignment: 'false'
DisableFormat: 'false'
IncludeBlocks: Preserve
IndentCaseLabels: 'true'
IndentPPDirectives: None
IndentWidth: '2'
IndentWrappedFunctionNames: 'false'
KeepEmptyLinesAtTheStartOfBlocks: 'true'
Language: Cpp
MaxEmptyLinesToKeep: '2'
PointerAlignment: Right
ReflowComments: 'true'
SortIncludes: 'false'
SpaceAfterCStyleCast: 'true'
SpaceBeforeAssignmentOperators: 'true'
SpaceBeforeParens: ControlStatements
SpaceInEmptyParentheses: 'false'
SpacesBeforeTrailingComments: '1'
SpacesInCStyleCastParentheses: 'false'
SpacesInParentheses: 'false'
SpacesInSquareBrackets: 'false'
TabWidth: '8'
UseTab: Never
...

450
firmware/asdf/src/asdf.c Normal file
View File

@ -0,0 +1,450 @@
// File recommented by recomment.cpp
// on Dec 9 2019 at 10:14:05.
//
// -*- mode: C; tab-width: 2 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF firmware - small, fast, and simple keyboard encoder.
//
// asdf.c
//
// This file contains code for:
// - the main scan code and key handler routines
// - key matrix declarations and keyboard state variables not delegated
// elsewhere.
// - Key debouncing logic and data stuctures
// - dispatch of special functions bound to keys.
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
#include <stdint.h>
#include "asdf.h"
#include "asdf_ascii.h"
#include "asdf_keymaps.h"
#include "asdf_repeat.h"
#include "asdf_modifiers.h"
#include "asdf_buffer.h"
#include "asdf_arch.h"
static asdf_cols_t last_stable_key_state[ASDF_NUM_ROWS];
// Each key is debounced separately, supporting true N-key rollover, allowing a
// new key to be pressed when the previously pressed key is still debouncing.
// This requires a debounce counter for each key. This is is a large RAM
// footprint, 64 bytes for an 8 x 8 key matrix. It would be possible to only
// debounce the most recently pressed key and reduce the RAM usage to a single
// debounce counuter. However, this would probably require different handling of
// key presses and releases, and special handling for modifier keys, perhaps
// including separate debounce logic in the handlers for toggle keys such as
// CAPS_LOCK.
static uint8_t debounce_counters[ASDF_NUM_ROWS][ASDF_NUM_COLS];
// store the last key pressed
static asdf_keycode_t last_key;
// handle for the char output buffer
static asdf_buffer_handle_t asdf_keycode_buffer;
// PROCEDURE: asdf_put_code
// INPUTS: (asdf_keycode_t) code: code to be buffered for output
// OUTPUTS: none
//
// DESCRIPTION: Takes a keycode argument and buffers for output.
//
// SIDE EFFECTS: modifies buffer state.
//
// NOTES: If buffer is full, silently drop the code.
//
// SCOPE: public
//
// COMPLEXITY: 1
//
void asdf_put_code(asdf_keycode_t code)
{
asdf_buffer_put(asdf_keycode_buffer, code);
}
// PROCEDURE: asdf_get_code
// INPUTS: none
// OUTPUTS: (asdf_keycode_t) returns next value in buffer.
//
// DESCRIPTION: Takes a keycode argument and buffers for output.
//
// SIDE EFFECTS: modifies buffer state.
//
// NOTES: If buffer is full, silently drop the code.
//
// SCOPE: public
//
// COMPLEXITY: 1
//
asdf_keycode_t asdf_get_code(void)
{
return asdf_buffer_get(asdf_keycode_buffer);
}
// PROCEDURE: asdf_lookup_keycode
// INPUTS: row, col: specify a row and column in the keyboard matrix
// OUTPUTS: returns a keycode
//
// DESCRIPTION: Given a row and column in the keyboard matrix, returns the
// corresponding keycode, depending on the state of the modifier keys.
//
// SIDE EFFECTS: none
//
// NOTES:
//
// SCOPE: private
//
// COMPLEXITY: 1
//
asdf_keycode_t asdf_lookup_keycode(uint8_t row, uint8_t col)
{
return asdf_keymaps_get_code(row, col, asdf_modifier_index());
}
// PROCEDURE: asdf_activate_action
// INPUTS: keycode: an action key code
// OUTPUTS: none
//
// DESCRIPTION: This routine is called when a key bound to an action code is
// pressed, and maps the action code to a function call, or other action
// appropriate for activation of the function.
//
// SIDE EFFECTS: All the actions may have side effects, depending on the function called.
//
// SCOPE: private
//
// COMPLEXITY: 1
//
static void asdf_activate_action(action_t keycode)
{
switch (keycode) {
case ACTION_SHIFT: {
asdf_modifier_shift_activate();
break;
}
case ACTION_SHIFT_LOCK: {
asdf_modifier_shiftlock_activate();
break;
}
case ACTION_CAPS: {
asdf_modifier_capslock_activate();
break;
}
case ACTION_CTRL: {
asdf_modifier_ctrl_activate();
break;
}
case ACTION_REPEAT: {
asdf_repeat_activate();
break;
}
case ACTION_NOTHING:
case ACTION_LOCAL:
case ACTION_BREAK:
case ACTION_HERE_IS:
case ACTION_FN_1:
case ACTION_FN_2:
case ACTION_FN_3:
case ACTION_FN_4:
case ACTION_FN_5:
case ACTION_FN_6:
case ACTION_FN_7:
case ACTION_FN_8:
case ACTION_FN_9:
case ACTION_FN_10:
case ACTION_CLEAR:
default: break;
}
}
// PROCEDURE: asdf_deactivate_action
// INPUTS: keycode: an action key code
// OUTPUTS: none
//
// DESCRIPTION: This routine is called when a key bound to an action code is
// released, and maps the action code to a function call, or other action
// appropriate for deactivation of the function.
//
// SIDE EFFECTS: All the actions may have side effects, depending on the function called.
//
// SCOPE: private
//
// COMPLEXITY: 1
//
static void asdf_deactivate_action(action_t keycode)
{
switch (keycode) {
case ACTION_SHIFT: {
asdf_modifier_shift_deactivate();
break;
}
case ACTION_SHIFT_LOCK: {
asdf_modifier_shiftlock_deactivate();
break;
}
case ACTION_CAPS: {
asdf_modifier_capslock_deactivate();
break;
}
case ACTION_CTRL: {
asdf_modifier_ctrl_deactivate();
break;
}
case ACTION_REPEAT: {
asdf_repeat_deactivate();
}
case ACTION_NOTHING:
case ACTION_LOCAL:
case ACTION_BREAK:
case ACTION_HERE_IS:
case ACTION_FN_1:
case ACTION_FN_2:
case ACTION_FN_3:
case ACTION_FN_4:
case ACTION_FN_5:
case ACTION_FN_6:
case ACTION_FN_7:
case ACTION_FN_8:
case ACTION_FN_9:
case ACTION_FN_10:
case ACTION_CLEAR:
default: break;
}
}
// PROCEDURE: asdf_activate_key
// INPUTS: keycode - the code for a key that has been pressed.
// OUTPUTS: none
//
// DESCRIPTION: Called when a key has been pressed. If the key is bound to a
// value, output the value. If the key is bound to an action, call the activate action
// handler with the keycode.
//
// SIDE EFFECTS: If the code is a value, the last key is updated to the current
// value, and repeat timer is reset. If the code is an action code, the activate
// action dispatcher produces side effects. See asdf_activate_action()
//
// SCOPE: private
//
// COMPLEXITY: 2
//
static void asdf_activate_key(asdf_keycode_t keycode)
{
if (keycode & ASDF_ACTION) {
asdf_activate_action((action_t) keycode);
}
else {
// activate a new codable keypress
asdf_put_code(keycode);
if (last_key != keycode) {
last_key = keycode;
asdf_repeat_reset_count();
}
}
}
// PROCEDURE: asdf_deactivate_key
// INPUTS: keycode - the code for a key that has been released
// OUTPUTS: none
//
// DESCRIPTION: Called when a key has been released. If the key is bound to a
// value, output the value. If the key is bound to an action, call the deactivate
// action handler with the keycode.
//
// SIDE EFFECTS: If the code is a value, the last key is set to ACTION_NOTHING,
// which is effectively a NOP. If the code is an action code, the deactivate action
// dispatcher produces side effects. See asdf_deactivate_action()
//
// SCOPE: private
//
// COMPLEXITY: 2
//
static void asdf_deactivate_key(asdf_keycode_t keycode)
{
if (keycode & ASDF_ACTION) {
asdf_deactivate_action((action_t) keycode);
}
else {
// deactivate a released keypress
if (last_key == keycode) {
last_key = ACTION_NOTHING;
}
}
}
// PROCEDURE: asdf_init
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Reserve an output buffer to hold keycodes to be sent, and
// initialize the keyboard state and debounce counters
//
// SIDE EFFECTS: see DESCRIPTION
//
// SCOPE: public
//
// COMPLEXITY: 3
//
void asdf_init(void)
{
last_key = ACTION_NOTHING;
asdf_modifiers_init();
asdf_repeat_init();
asdf_keymaps_init();
asdf_buffer_init();
// reserve a buffer:
asdf_keycode_buffer = asdf_buffer_new(ASDF_KEYCODE_BUFFER_SIZE);
for (uint8_t row = 0; row < ASDF_NUM_ROWS; row++) {
last_stable_key_state[row] = 0;
for (uint8_t col = 0; col < ASDF_NUM_COLS; col++) {
debounce_counters[row][col] = ASDF_DEBOUNCE_TIME_MS;
}
}
}
// PROCEDURE: asdf_handle_key_press_or_release
// INPUTS: row, col: the row and column number of the key that has changed.
// OUTPUTS: none
//
// DESCRIPTION: Given a row and column of a key that has changed:
//
// 1) Debounce the key by decrementing a debounce timer. If not yet debounced,
// return.
// 2) When the key is debounced, if the key is pressed, then call the activation
// function associated with the key. Otherwise, if the key is released, call
// the deactivation function for the key.
//
// SIDE EFFECTS: - Modifies debounce counter for the row and column
// - After key debounces, modifies the table of stable key states
// - Activate/deactivate functions have side effects
//
// NOTES:
//
// SCOPE: private
//
// COMPLEXITY: 3
//
static void asdf_handle_key_press_or_release(uint8_t row, uint8_t col, uint8_t key_was_pressed)
{
uint8_t *debounce_count = &debounce_counters[row][col];
if (!(--(*debounce_count))) {
// debounce timed out. Set new stable state and activate or
// deactivate key.
*debounce_count = ASDF_DEBOUNCE_TIME_MS;
if (key_was_pressed) {
last_stable_key_state[row] |= 1 << col;
asdf_activate_key(asdf_lookup_keycode(row, col));
}
else {
// key was released
last_stable_key_state[row] &= ~(1 << col);
asdf_deactivate_key(asdf_lookup_keycode(row, col));
}
}
}
// PROCEDURE: asdf_handle_key_held_pressed
// INPUTS: row, col: The row and column of a key that is being held down
// OUTPUTS: none
//
// DESCRIPTION: Given a row and column of a key that has been debounced and
// continues to be pressed:
// 1) Determine if this is the last key pressed.
// 2) If it's the most recent key, then check to see if it's time to repeat the key code.
// 3) If it's time to repeat, then do the repeat and reset the repeat timer.
//
// SIDE EFFECTS:
// - Causes repeat timer to tick, and may reset the repeat timer.
// - activate_key() will send a key code.
//
// NOTES: last_key is always a key code, never an action function, so only valid
// key codes will be repeated.
//
// SCOPE: private
//
// COMPLEXITY: 3
//
static void asdf_handle_key_held_pressed(uint8_t row, uint8_t col)
{
if (asdf_lookup_keycode(row, col) == last_key) {
// if last debounced code-producing key is still pressed, handle repeat
if (asdf_repeat()) {
asdf_activate_key(last_key);
}
}
}
// PROCEDURE: asdf_keyscan
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Scans the key matrix. For each row, read the columns and compare
// with last stable state. For each changed key, call a key-change handler
// function. For each stable pressed key, call a "continued press" handler
// function.
//
// SIDE EFFECTS:
//
// NOTES: 1) The keyboard state is stored as an array of words, with one word
// per row, and each bit in a word representing one key in the row.
//
// 2) While it is tempting to use bit hacks to reduce the number of
// cycles through the inner loop, I have opted to just loop over all
// the bits (as long as there are some changed or pressed keys). For
// an 8-bit word, bit tricks don't deliver much performance boost,
// but do decrease code clarity.
//
// COMPLEXITY: 5
//
void asdf_keyscan(void)
{
for (uint8_t row = 0; row < ASDF_NUM_ROWS; row++) {
asdf_cols_t row_key_state = asdf_arch_read_row(row);
asdf_cols_t changed = row_key_state ^ last_stable_key_state[row];
// loop over the bits until all changed or pressed keys in the row are handled.
for (uint8_t col = 0; (changed | row_key_state) && col < ASDF_NUM_COLS; col++) {
if (changed & 1) {
// key state is different from last stable state
asdf_handle_key_press_or_release(row, col, row_key_state & 1);
}
else if (row_key_state & 1) {
asdf_handle_key_held_pressed(row, col);
}
changed >>= 1;
row_key_state >>= 1;
}
}
}
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

100
firmware/asdf/src/asdf.h Normal file
View File

@ -0,0 +1,100 @@
// -*- mode: C; tab-width: 4 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf.h
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
//
#if !defined(ASDF_H)
#define ASDF_H
#define ASDF_NUM_ROWS 8
#define ASDF_NUM_COLS 8
#define ASDF_ACTION 0x80
#define ASDF_INVALID_CODE 0x80
// an action code is not a valid keycode.
// for efficiency on 8-bit machines, use 8 columns per row. For 16 columns per
// row, change cols_t to uint16_t and increase ASDF_NUM_COLS.
typedef uint8_t asdf_cols_t;
// ASCII keycodes are 7 bits. An 8-bit datatype encodes ASCII, plus a flag for a
// key function. For longer codes, such as extended ASCII or unicode, change
// keycode_t appropriately, and also change ASDF_ACTION so that the action key
// codes (enumerated in action_t) do not conflict with the encoding scheme.
typedef uint8_t asdf_keycode_t;
typedef enum {
ACTION_NOTHING = ASDF_ACTION,
ACTION_SHIFT = ASDF_ACTION + 0x01,
ACTION_SHIFT_LOCK = ASDF_ACTION + 0x02,
ACTION_CAPS = ASDF_ACTION + 0x03,
ACTION_CTRL = ASDF_ACTION + 0x04,
ACTION_REPEAT = ASDF_ACTION + 0x05,
ACTION_LOCAL = ASDF_ACTION + 0x06,
ACTION_BREAK = ASDF_ACTION + 0x07,
ACTION_HERE_IS = ASDF_ACTION + 0x08,
ACTION_CLEAR = ASDF_ACTION + 0x09,
ACTION_FN_1 = ASDF_ACTION + 0x11,
ACTION_FN_2 = ASDF_ACTION + 0x12,
ACTION_FN_3 = ASDF_ACTION + 0x13,
ACTION_FN_4 = ASDF_ACTION + 0x14,
ACTION_FN_5 = ASDF_ACTION + 0x15,
ACTION_FN_6 = ASDF_ACTION + 0x16,
ACTION_FN_7 = ASDF_ACTION + 0x17,
ACTION_FN_8 = ASDF_ACTION + 0x18,
ACTION_FN_9 = ASDF_ACTION + 0x19,
ACTION_FN_10 = ASDF_ACTION + 0x1a
} action_t;
// PROCEDURE: asdf_init
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: initialize the keyboard state and debounce counters
void asdf_init(void);
// PROCEDURE: asdf_keyscan
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Scans the key matrix. For each row, read the columns and compare
// with last stable state. For each changed key, call a key-change handler
// function. For each stable pressed key, call a "continued press" handler
// function.
void asdf_keyscan(void);
// PROCEDURE: asdf_put_code
// INPUTS: (asdf_keycode_t) code: code to be buffered for output
// OUTPUTS: none
// DESCRIPTION: Takes a keycode argument and buffers for output.
// NOTES: If buffer is full, silently drop the code.
void asdf_put_code(asdf_keycode_t code);
// PROCEDURE: asdf_get_code
// INPUTS: none
// OUTPUTS: (asdf_keycode_t) returns next value in buffer.
// DESCRIPTION: Takes a keycode argument and buffers for output.
asdf_keycode_t asdf_get_code(void);
#endif // !defined (ASDF_H)
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

90
firmware/asdf/src/asdf_ascii.h Normal file
View File

@ -0,0 +1,90 @@
// File recommented by recomment.cpp
// on Dec 9 2019 at 10:14:05.
//
// -*- mode: C; tab-width: 4 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_ascii.h
//
// This file contains definitions of ASCII control cods and certain symbols, in
// order to avoid escaping special characters in the keymap definitions, and to
// improve keymap readability.
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
//
#if !defined(ASDF_ASCII_H)
#define ASDF_ASCII_H
typedef enum {
ASCII_CTRL_A = 0x01,
ASCII_CTRL_B = 0x02,
ASCII_CTRL_C = 0x03,
ASCII_CTRL_D = 0x04,
ASCII_CTRL_E = 0x05,
ASCII_CTRL_F = 0x06,
ASCII_CTRL_G = 0x07,
ASCII_CTRL_H = 0x08,
ASCII_CTRL_I = 0x09,
ASCII_CTRL_J = 0x0a,
ASCII_CTRL_K = 0x0b,
ASCII_CTRL_L = 0x0c,
ASCII_CTRL_M = 0x0d,
ASCII_CTRL_N = 0x0e,
ASCII_CTRL_O = 0x0f,
ASCII_CTRL_P = 0x10,
ASCII_CTRL_Q = 0x11,
ASCII_CTRL_R = 0x12,
ASCII_CTRL_S = 0x13,
ASCII_CTRL_T = 0x14,
ASCII_CTRL_U = 0x15,
ASCII_CTRL_V = 0x16,
ASCII_CTRL_W = 0x17,
ASCII_CTRL_X = 0x18,
ASCII_CTRL_Y = 0x19,
ASCII_CTRL_Z = 0x1a,
ASCII_ESC = 0x1b,
ASCII_SPACE = 0x20,
ASCII_AT = 0x40,
ASCII_COMMA = 0x44,
ASCII_LT_CURLY_BRACE = 0x7b,
ASCII_RT_CURLY_BRACE = 0x7d,
ASCII_LT_SQUARE_BRACE = 0x5b,
ASCII_RT_SQUARE_BRACE = 0x5d,
ASCII_LT_PAREN = 0x28,
ASCII_RT_PAREN = 0x29,
ASCII_SINGLE_QUOTE = 0x27,
ASCII_DOUBLE_QUOTE = 0x22,
ASCII_BACKSLASH = 0x5c,
ASCII_GRAVE_ACCENT = 0x60,
ASCII_PERIOD = 0x2e,
ASCII_TILDE = 0x7e,
ASCII_VERT_BAR = 0x7c,
ASCII_DEL = 0x7f
} ascii;
#define ASCII_LF ASCII_CTRL_J
#define ASCII_CR ASCII_CTRL_M
#define ASCII_TAB ASCII_CTRL_I
#endif // !defined (ASDF_ASCII_H)
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

183
firmware/asdf/src/asdf_buffer.c Normal file
View File

@ -0,0 +1,183 @@
// -*- mode: C; tab-width: 2 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_buffer.c
//
// Provides an interface between the generation of keycodes and the
// hardware-level keycode transmission. Any buffering, etcc. occurs here.
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
#include <stdio.h>
#include <stdint.h>
#include "asdf.h"
#include "asdf_buffer.h"
typedef struct {
asdf_keycode_t *buf;
int16_t size;
uint8_t head;
uint8_t tail;
uint8_t count;
} asdf_buffer_t;
static asdf_keycode_t buffer_pool[ASDF_BUFFER_POOL_SIZE];
static asdf_buffer_t buffers[ASDF_BUFFER_NUM_HANDLES];
static int16_t buffer_free;
static asdf_buffer_handle_t next_handle;
// PROCEDURE: asdf_buffer_init
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Initialize the buffer pool and handles
//
// SIDE EFFECTS: See description
//
// NOTES:
//
// SCOPE: public
//
// COMPLEXITY: 1
//
void asdf_buffer_init(void)
{
buffer_free = 0;
next_handle = 0;
}
// PROCEDURE: buffer_handle_valid
// INPUTS: (uint8_t) handle - handle to be checked
// OUTPUTS: returns TRUE if the handle is a valid allocated handle.
//
// DESCRIPTION: Returns TRUE if the handle is one that has been allocated.
//
// SIDE EFFECTS: none
//
// NOTES:
//
// SCOPE: private
//
// COMPLEXITY: 1
//
uint8_t buffer_handle_valid(asdf_buffer_handle_t handle)
{
return ((handle >= 0) && (handle < next_handle));
}
// PROCEDURE: asdf_buffer_new
// INPUTS: (uint16_t) size: size of the buffer to allocate.
//
// OUTPUTS: returns a uint8_t handle to identify the buffer allocated from the
// pool.
//
// DESCRIPTION: Receives a request to allocate a fixed-size buffer from the
// pool. If there is enough room in the buffer pool, and if a buffer handle is
// available, then allocate space from the pool, initialize the next available
// buffer struct, and return the handle.
//
// SIDE EFFECTS: see above
//
// SCOPE: public
//
// COMPLEXITY: 3
//
asdf_buffer_handle_t asdf_buffer_new(int16_t size)
{
asdf_buffer_handle_t handle = ASDF_BUFFER_INVALID;
if (next_handle < ASDF_BUFFER_NUM_HANDLES) {
if (size <= (ASDF_BUFFER_POOL_SIZE - buffer_free)) {
handle = next_handle++;
buffers[handle].size = size;
buffers[handle].buf = &buffer_pool[buffer_free];
buffers[handle].head = 0;
buffers[handle].tail = 0;
buffers[handle].count = 0;
buffer_free += size;
}
}
return handle;
}
// PROCEDURE: asdf_buffer_put
//
// INPUTS:(asdf_buffer_t) buffer_handle: pointer to the buffer struct.
// (asdf_keycode_t) code: code to be added to the queue.
//
// OUTPUTS: None
//
// DESCRIPTION: Add the keycode to the head of the output buffer. If the buffer
// is full, quietly drop the keycode.
//
// SIDE EFFECTS: See DESCRIPTION
//
// NOTES:
//
// COMPLEXITY: 3
//
// SCOPE: public
//
void asdf_buffer_put(asdf_buffer_handle_t handle, asdf_keycode_t code)
{
if (buffer_handle_valid(handle)) {
if (buffers[handle].count < buffers[handle].size) {
buffers[handle].buf[buffers[handle].head] = code;
buffers[handle].head = (buffers[handle].head + 1) % buffers[handle].size;
buffers[handle].count++;
}
}
}
// PROCEDURE: asdf_buffer_get
//
// INPUTS: None
//
// OUTPUTS: returns next code in the buffer.
//
// DESCRIPTION: Gets the next queued code in the output buffer and return the
// value.
//
// SIDE EFFECTS: Removes a code from the queue.
//
// NOTES: If the buffer is empty, the code ASDF_INVALID_CODE is returned.
//
// COMPLEXITY: 2
//
// SCOPE: Public
//
asdf_keycode_t asdf_buffer_get(asdf_buffer_handle_t handle)
{
asdf_keycode_t code = ASDF_INVALID_CODE;
if (buffers[handle].count) {
code = buffers[handle].buf[buffers[handle].tail];
buffers[handle].tail = (buffers[handle].tail + 1) % buffers[handle].size;
buffers[handle].count--;
}
return code;
}
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

76
firmware/asdf/src/asdf_buffer.h Normal file
View File

@ -0,0 +1,76 @@
// -*- mode: C; tab-width: 4 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_buffer.h
//
// Contains definitions and prototypes for the asdf keycode output buffer.
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
//
#if !defined(ASDF_BUFFER_H)
#define ASDF_BUFFER_H
#include "asdf_config.h"
#define ASDF_BUFFER_POOL_SIZE ASDF_KEYCODE_BUFFER_SIZE
#define ASDF_BUFFER_INVALID -1
// Setting the number of handles to 1 will work if only one buffer is requrired,
// and will save a few bytes of RAM. But the test code needs at least 2 buffer
// handles to test the module, so we leave it at 2.
#define ASDF_BUFFER_NUM_HANDLES 2
typedef int16_t asdf_buffer_handle_t;
// PROCEDURE: asdf_buffer_init
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Initialize the buffer pool and handles
void asdf_buffer_init(void);
// PROCEDURE: asdf_buffer_new
// INPUTS: (uint16_t) size: size of the buffer to allocate.
// OUTPUTS: returns (asdf_buffer_handle_t) handle to identify the buffer allocated from the
// pool.
// DESCRIPTION: Receives a request to allocate a fixed-size buffer from the
// pool. If there is enough room in the buffer pool, and if a buffer handle is
// available, then allocate space from the pool, initialize the next available
// buffer struct, and return the handle.
asdf_buffer_handle_t asdf_buffer_new(int16_t size);
// PROCEDURE: asdf_buffer_put
// INPUTS:(asdf_buffer_t) buffer_handle: pointer to the buffer struct.
// (asdf_keycode_t) code: code to be added to the queue.
// OUTPUTS: None
// DESCRIPTION: Add the keycode to the head of the output buffer. If the buffer
// is full, quietly drop the keycode.
void asdf_buffer_put(asdf_buffer_handle_t handle, asdf_keycode_t code);
// PROCEDURE: asdf_buffer_get
// INPUTS: None
// OUTPUTS: returns next code in the buffer.
// DESCRIPTION: Gets the next queued code in the output buffer and return the
// value.
asdf_keycode_t asdf_buffer_get(asdf_buffer_handle_t handle);
#endif // !defined (ASDF_BUFFER_H)
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

54
firmware/asdf/src/asdf_config.h Normal file
View File

@ -0,0 +1,54 @@
// -*- mode: C; tab-width: 4 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_config.h
//
// This file gathers configuration parameters related to the user-detectable
// keyboard experience. For example, put key debounce times, repeat rates,
// buffer sized, baud rates, etc. here. Details such as processor clock speed,
// etc. should go in the architecture-dependent files. System details such as
// number of buffer handles, etc. should go with the appropriate module, but
// certain buffer sized may go here if they can affect the user experience (such
// as how long a macro can be).
//
// Copyright 2019 David Fenyes
// 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 3 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 <https://www.gnu.org/licenses/>.
//
#if !defined (CONFIG_H)
#define CONFIG_H
// size of the keycode output buffer.
#define ASDF_KEYCODE_BUFFER_SIZE 16
// key debounce period (in msec)
#define ASDF_DEBOUNCE_TIME_MS 10
// Autorepeat default behavior. Set to REPEAT_AUTO for default autorepeat.
// Set to REPEAT_OFF for default no autorepeat by default.
#define ASDF_DEFAULT_REPEAT_STATE REPEAT_AUTO
// time to hold down a key in milliseconds before autorepeat starts
#define ASDF_AUTOREPEAT_TIME_MS 525 // 525 msec.
// time between repeats of a character with repeat key held, or in autorepeat (milliseconds)
#define ASDF_REPEAT_TIME_MS (1000 / 15) // l5 characters per sec.
#endif /* !defined (CONFIG_H) */
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

82
firmware/asdf/src/asdf_keymaps.c Normal file
View File

@ -0,0 +1,82 @@
// -*- mode: C; tab-width: 2 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_keymaps.c
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
#include <stdint.h>
#include "asdf.h"
#include "asdf_arch.h"
#include "asdf_keymaps.h"
typedef asdf_keycode_t keycode_matrix_t[ASDF_NUM_ROWS][ASDF_NUM_COLS];
static const FLASH keycode_matrix_t plain_matrix = ASCII_PLAIN_MAP;
static const FLASH keycode_matrix_t shift_matrix = ASCII_SHIFT_MAP;
static const FLASH keycode_matrix_t caps_matrix = ASCII_CAPS_MAP;
static const FLASH keycode_matrix_t ctrl_matrix = ASCII_CTRL_MAP;
static keycode_matrix_t const *modifier_matrix[MOD_NUM_MAPS];
// PROCEDURE: asdf_keymaps_init
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Assigns the keymaps to the indices specified by the modifier
// index, to avoid hard-coding constant index values.
//
// SIDE EFFECTS: builds up the private map table.
//
// SCOPE: public
//
// COMPLEXITY: 1
//
void asdf_keymaps_init(void)
{
modifier_matrix[MOD_PLAIN_MAP] = &plain_matrix;
modifier_matrix[MOD_SHIFT_MAP] = &shift_matrix;
modifier_matrix[MOD_CAPS_MAP] = &caps_matrix;
modifier_matrix[MOD_CTRL_MAP] = &ctrl_matrix;
}
// PROCEDURE: asdf_keymaps_get_code
// INPUTS: row, col: row and column of key that has been pressed
// modifiers_index: index into the keymap array, based on modifier state
// OUTPUTS: returns a key code.
//
// DESCRIPTION: Given a key row and column, and an index based on modifier
// state, return the appropriate keycode.
//
// SIDE EFFECTS: none
//
// SCOPE: public
//
// COMPLEXITY: 1
//
asdf_keycode_t asdf_keymaps_get_code(const uint8_t row, const uint8_t col,
const uint8_t modifier_index)
{
const keycode_matrix_t *matrix = modifier_matrix[modifier_index];
return FLASH_READ_MATRIX_ELEMENT(*matrix, row, col);
}
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

220
firmware/asdf/src/asdf_modifiers.c Normal file
View File

@ -0,0 +1,220 @@
// File recommented by recomment.cpp
// on Dec 9 2019 at 10:14:05.
//
// -*-mode : C;
// tab - width : 2; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_modifiers.c
//
// This file contains the logic for the modifier keys. Any new modifiers or
// special handling goes here.
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
#include <stdint.h>
#include "asdf_modifiers.h"
static shift_state_t shift_state;
static caps_state_t caps_state;
static ctrl_state_t ctrl_state;
static shiftlock_mode_t asdf_toggle_shiftlock;
static const modifier_index_t modifier_indices[] = {
MOD_PLAIN_MAP, // 0x00: no modifiers
MOD_SHIFT_MAP, // 0x01: only SHIFT active
MOD_CAPS_MAP, // 0x02: only CAPS active
MOD_SHIFT_MAP, // 0x03: CAPS and SHIFT active
MOD_CTRL_MAP, // CTRL overrides SHIFT and CAPS
MOD_CTRL_MAP, MOD_CTRL_MAP, MOD_CTRL_MAP
};
// PROCEDURE: asdf_modifier_shift_activate
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: sets SHIFT state to ON
//
// SIDE EFFECTS: see DESCRIPTION
//
// COMPLEXITY: 1
//
void asdf_modifier_shift_activate(void)
{
shift_state = SHIFT_ON_ST;
}
// PROCEDURE: asdf_modifier_shiftlock_activate
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: sets SHIFTLOCK state depending on the mode.
//
// SHIFTLOCK normal mode:
// - SHIFTLOCK always activates shift mode
// - Pressing and Relasing SHIFT deactivates shift mode.
//
// SHIFTLOCK toggle mode:
// - Pressing SHIFTLOCK toggles the shift mode on and off
// - Pressing and Relasing SHIFT deactivates shift mode.
//
// NOTES: The test of the shiftlock mode constant always has the same result and
// will therefore be optimized by the compiler, so technically no added
// cyclometric complexity, but count it anyway, in case this is made into a
// user-definable behavior later.
//
// SIDE EFFECTS: affects shift_state as described.
//
// COMPLEXITY: 2
//
void asdf_modifier_shiftlock_activate(void)
{
if (asdf_toggle_shiftlock) {
shift_state ^= SHIFT_LOCKED_ST;
}
else {
shift_state |= SHIFT_LOCKED_ST;
}
}
// PROCEDURE: asdf_modifier_capslock_activate
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Turns on Capslock state
//
// SIDE EFFECTS: see DESCRIPTION
//
// COMPLEXITY: 1
//
void asdf_modifier_capslock_activate(void)
{
caps_state ^= CAPS_ON_ST;
}
// PROCEDURE: asdf_modifier_ctrl_activate
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Turns on CTRL mode
//
// SIDE EFFECTS: see DESCRIPTION
//
// COMPLEXITY: 1
//
void asdf_modifier_ctrl_activate(void)
{
ctrl_state = CTRL_ON_ST;
}
// PROCEDURE: asdf_modifier_shift_deactivate
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Turns off shift mode.
//
// SIDE EFFECTS: See DESCRIPTION
//
// NOTES: this also clears any SHIFT_LOCK condition.
//
// COMPLEXITY: 1
//
void asdf_modifier_shift_deactivate(void)
{
shift_state = SHIFT_OFF_ST;
}
// PROCEDURE: asdf_modifier_ctrl_deactivate
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Turns off CTRL mode
//
// SIDE EFFECTS: See DESCRIPTION
//
// COMPLEXITY: 1
//
void asdf_modifier_ctrl_deactivate(void)
{
ctrl_state = CTRL_OFF_ST;
}
// PROCEDURE: asdf_modifier_shiftlock_deactivate
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Does nothing. This is called when releasing the SHIFT LOCK key,
// and no action is performed on releasing a SHIFT LOCK key
//
// SIDE EFFECTS: none
//
// COMPLEXITY: 1
//
void asdf_modifier_shiftlock_deactivate(void) {}
// PROCEDURE: asdf_modifier_capslock_deactivate
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Does nothing. This is called when releasing the CAPS LOCK key,
// and no action is performed on releasing the CAPS LOCK key.
//
// SIDE EFFECTS: none
//
// COMPLEXITY: 1
//
void asdf_modifier_capslock_deactivate(void) {}
// PROCEDURE: asdf_modifiers_init
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Initialize the modifier key state variables to OFF state
//
// SIDE EFFECTS: see DESCRIPTION
//
// COMPLEXITY: 1
//
void asdf_modifiers_init(void)
{
shift_state = SHIFT_OFF_ST;
caps_state = CAPS_OFF_ST;
ctrl_state = CTRL_OFF_ST;
asdf_toggle_shiftlock = HOLD_SHIFTLOCK;
}
// PROCEDURE: asdf_modifier_index
// INPUTS: none
// OUTPUTS: returns uint8_t index into key map, based on modifier key status
//
// DESCRIPTION: See OUTPUTS
//
// SIDE EFFECTS: none
//
// COMPLEXITY: 1
//
modifier_index_t asdf_modifier_index(void)
{
return modifier_indices[((uint8_t)(shift_state & 1) // shift active
| ((uint8_t)(shift_state >> 1)) // shiftlock active
| (uint8_t) caps_state // caps active
| (uint8_t) ctrl_state)]; // ctrl active
}

116
firmware/asdf/src/asdf_modifiers.h Normal file
View File

@ -0,0 +1,116 @@
// File recommented by recomment.cpp
// on Dec 9 2019 at 10:14:05.
//
// -*- mode: C; tab-width: 4 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_modifiers.h
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
#if !defined(ASDF_MODIFIERS_H)
#define ASDF_MODIFIERS_H
typedef enum { SHIFT_OFF_ST = 0, SHIFT_ON_ST = 0x01, SHIFT_LOCKED_ST = 0x02 } shift_state_t;
typedef enum { CAPS_OFF_ST = 0, CAPS_ON_ST = 0x02 } caps_state_t;
typedef enum { CTRL_OFF_ST = 0, CTRL_ON_ST = 0x04 } ctrl_state_t;
typedef enum {
MOD_PLAIN_MAP = 0,
MOD_SHIFT_MAP,
MOD_CAPS_MAP,
MOD_CTRL_MAP,
MOD_NUM_MAPS
} modifier_index_t;
typedef enum { TOGGLE_SHIFTLOCK = 0, HOLD_SHIFTLOCK = 1 } shiftlock_mode_t;
// PROCEDURE: asdf_modifier_shift_activate
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: sets SHIFT state to ON
//
void asdf_modifier_shift_activate(void);
// PROCEDURE: asdf_modifier_shiftlock_activate
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: sets SHIFTLOCK state if in NORMAL mode, and toggle shiftlock if in TOGGLE mode.
//
void asdf_modifier_shiftlock_activate(void);
// PROCEDURE: asdf_modifier_capslock_activate
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Turns on Capslock state
//
void asdf_modifier_capslock_activate(void);
// PROCEDURE: asdf_modifier_ctrl_activate
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Turns on CTRL mode
//
void asdf_modifier_ctrl_activate(void);
// PROCEDURE: asdf_modifier_shift_deactivate
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Turns off shift mode.
//
void asdf_modifier_shift_deactivate(void);
// PROCEDURE: asdf_modifier_ctrl_deactivate
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Turns off CTRL mode
//
void asdf_modifier_ctrl_deactivate(void);
// PROCEDURE: asdf_modifier_shiftlock_deactivate
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: No action. This is called when releasing the SHIFT LOCK key,
//
void asdf_modifier_shiftlock_deactivate(void);
// PROCEDURE: asdf_modifier_capslock_deactivate
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: No action. Called when releasing the CAPS LOCK key.
//
void asdf_modifier_capslock_deactivate(void);
// PROCEDURE: asdf_modifiers_init
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Initialize the modifier key state variables to OFF state
//
void asdf_modifiers_init(void);
// PROCEDURE: asdf_modifier_index
// INPUTS: none
// OUTPUTS: returns uint8_t index into key map, based on modifier key status
// DESCRIPTION: See OUTPUTS
//
modifier_index_t asdf_modifier_index(void);
#endif // !defined (ASDF_MODIFIERS_H)
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

180
firmware/asdf/src/asdf_repeat.c Normal file
View File

@ -0,0 +1,180 @@
// -*- mode: C; tab-width: 2 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_repeat.c
//
// This file contains the key repeat logic.
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
#include <stdint.h>
#include "asdf_repeat.h"
typedef uint16_t key_timer_t;
static repeat_state_t repeat_state;
static repeat_state_t base_repeat_state;
static key_timer_t key_repeat_timer;
// PROCEDURE: asdf_repeat_init
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Initialize the repeat state state machine
//
// SIDE EFFECTS: see DESCRIPTION
//
// COMPLEXITY: 1
//
void asdf_repeat_init(void)
{
repeat_state = base_repeat_state = ASDF_DEFAULT_REPEAT_STATE;
key_repeat_timer = (uint16_t) repeat_state;
}
// PROCEDURE: asdf_repeast_reset_count
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: resets the repeat counter for the current key, to begin a new
// repeat cycle. Resest is based on repeat state (no repeat, autorepeat, normal repeat).
//
// SIDE EFFECTS: see DESCRIPTION
//
// COMPLEXITY: 1
//
void asdf_repeat_reset_count(void)
{
key_repeat_timer = (key_timer_t) repeat_state;
}
// PROCEDURE: asdf_repeat_auto_off
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Turns Autorepeat mode off by setting the base state to
// autorepeat. If key is repeating, then the new behavior will be realized after
// the repeat key is released.
//
// SIDE EFFECTS: See DESCRIPTION
//
// SCOPE: public
//
// COMPLEXITY: 1
//
void asdf_repeat_auto_off(void)
{
base_repeat_state = REPEAT_OFF;
if (REPEAT_ON != repeat_state) {
key_repeat_timer = repeat_state = base_repeat_state;
}
}
// PROCEDURE: asdf_repeat_auto_on
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Turns Autorepeat mode on by setting the base state to
// autorepeat. If key is repeating, then the new behavior will be realized after
// the repeat key is released.
//
// SIDE EFFECTS: see above
//
// SCOPE: public
//
// COMPLEXITY: 1
//
void asdf_repeat_auto_on(void)
{
base_repeat_state = REPEAT_AUTO;
if (REPEAT_ON != repeat_state) {
key_repeat_timer = repeat_state = base_repeat_state;
}
}
// PROCEDURE: asdf_repeat_activate
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: set repeat state machine to repeat mode. Called when REPEAT key
// is pressed.
//
// SIDE EFFECTS: see DESCRIPTION
//
// NOTES: If a key is pressed and the key timer is less than or equal to the
// normal repeat rate, then don't change the timing, to avoid appearance of
// stuttering.
//
// COMPLEXITY: 1
//
void asdf_repeat_activate(void)
{
if (key_repeat_timer > REPEAT_ON || REPEAT_OFF == repeat_state) {
key_repeat_timer = repeat_state = REPEAT_ON;
}
}
// PROCEDURE: asdf_repeat_deactivate
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Reset repeat state machine to default state. Called when REPEAT
// key is released.
//
// SIDE EFFECTS: See DESCRIPTION
//
// NOTES: Releasing repeat disrupts any repeat timers. aIf a key is still held
// down after REPEAT is released, and autorepeat mode is enabled, then restart
// the autorepeat timer. Otherwise disable repeat.
//
// COMPLEXITY: 1
//
void asdf_repeat_deactivate(void)
{
key_repeat_timer = repeat_state = base_repeat_state;
}
// PROCEDURE: asdf_repeat
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: counts down the repeat timer (if activated) and returns a TRUE
// value when the counter times out. A true values indicates that the last value
// should be repeated to the output.
//
// SIDE EFFECTS: none
//
// NOTES: The key_repeat_timer is only decremented if it is nonzero.
//
// COMPLEXITY: 2
//
uint8_t asdf_repeat(void)
{
uint8_t timeout = (key_repeat_timer && !(--key_repeat_timer));
if (timeout) {
key_repeat_timer = REPEAT_ON;
}
return timeout;
}
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

87
firmware/asdf/src/asdf_repeat.h Normal file
View File

@ -0,0 +1,87 @@
// -*- mode: C; tab-width: 2 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// asdf_repeat.h
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
//
//
#if !defined(ASDF_REPEAT_H)
#define ASDF_REPEAT_H
#include "asdf_config.h"
typedef enum {
REPEAT_OFF = 0,
REPEAT_ON = ASDF_REPEAT_TIME_MS,
REPEAT_AUTO = ASDF_AUTOREPEAT_TIME_MS
} repeat_state_t;
// PROCEDURE: asdf_repeat_init
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Initialize the repeat state state machine
void asdf_repeat_init(void);
// PROCEDURE: asdf_repeast_reset_count
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: resets the repeat counter for the current key, to begin a new
// repeat cycle. Resest is based on repeat state (no repeat, autorepeat, normal repeat).
void asdf_repeat_reset_count(void);
// PROCEDURE: asdf_repeat_auto_off
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Turns Autorepeat mode off
void asdf_repeat_auto_off(void);
// PROCEDURE: asdf_repeat_auto_on
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Turns Autorepeat mode on
void asdf_repeat_auto_on(void);
// PROCEDURE: asdf_repeat_activate
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: set repeat state machine to repeat mode. Called when REPEAT key
// is pressed.
void asdf_repeat_activate(void);
// PROCEDURE: asdf_repeat_deactivate
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: Reset repeat state machine to default state. Called when REPEAT
// key is released.
void asdf_repeat_deactivate(void);
// PROCEDURE: asdf_repeat
// INPUTS: none
// OUTPUTS: none
// DESCRIPTION: counts down the repeat timer (if activated) and returns a TRUE
// value when the counter times out. A true values indicates that the last value
// should be repeated to the output.
uint8_t asdf_repeat(void);
#endif // !defined (FILENAME_H)
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

84
firmware/asdf/src/main.c Normal file
View File

@ -0,0 +1,84 @@
// -*- mode: C; tab-width: 2 ; indent-tabs-mode: nil -*-
//
// Universal Keyboard Project
// ASDF keyboard firmware
//
// main.c
//
// main program loop. Initialize hardware. Schedule key scans and i/o.
//
// Copyright 2019 David Fenyes
//
// 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 3 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 <https://www.gnu.org/licenses/>.
#include <stdint.h>
#include "asdf.h"
#include "asdf_arch.h"
#include "asdf_buffer.h"
// PROCEDURE: main
// INPUTS: none
// OUTPUTS: none
//
// DESCRIPTION: Initialize hardware, Schedule key scans and i/o
//
// SIDE EFFECTS: See above
//
// NOTES: This code just initializes the hardware, and then loops. The loop
// includes:
//
// - Check every 1 ms (or whatever the tick is set to), calls the keyboard
// scan routine.
//
// - Check every pass through if any characters are buffered to send. If so,
// send them.
//
// This is not the most efficient use of the hardware, but is an example of how
// the keyboard scanner is used. Of course, this loop can be replaced with an
// RTOS process as well. If an RTOS is used, then asdf_buffer can be modified
// to use RTOS message queues instead of an internal buffer, or to keep the
// internal buffer and use a counting semaphore to indicate characters in the
// buffer.
//
// If you are adding special functions when using an RTOS, make sure the
// functions do not block, or do any heavy computation. Rather, they should be
// small and pass messages to appropriate processes to handle the activities.
//
// COMPLEXITY: 2
//
int main(void)
{
// initialize the hardware:
asdf_arch_init();
// initialize the keyboard logic:
asdf_init();
while (1) {
if (asdf_arch_tick()) {
asdf_keycode_t code = asdf_get_code();
if (code != ASDF_INVALID_CODE) {
asdf_arch_send_code(code);
}
asdf_keyscan();
}
}
}
//-------|---------|---------+---------+---------+---------+---------+---------+
// Above line is 80 columns, and should display completely in the editor.

46
firmware/asdf/test/_clang-format Normal file
View File

@ -0,0 +1,46 @@
---
BasedOnStyle: Mozilla
AlignAfterOpenBracket: Align
AlignOperands: 'true'
AlignTrailingComments: 'true'
AllowAllParametersOfDeclarationOnNextLine: 'false'
AllowShortBlocksOnASingleLine: 'false'
AllowShortCaseLabelsOnASingleLine: 'true'
AllowShortFunctionsOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: 'false'
AllowShortLoopsOnASingleLine: 'true'
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: 'true'
BinPackArguments: 'true'
BinPackParameters: 'true'
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeBraces: Stroustrup
ColumnLimit: '100'
ConstructorInitializerIndentWidth: '2'
ContinuationIndentWidth: '2'
DerivePointerAlignment: 'false'
DisableFormat: 'false'
IncludeBlocks: Preserve
IndentCaseLabels: 'true'
IndentPPDirectives: None
IndentWidth: '2'
IndentWrappedFunctionNames: 'false'
KeepEmptyLinesAtTheStartOfBlocks: 'true'
Language: Cpp
MaxEmptyLinesToKeep: '2'
PointerAlignment: Right
ReflowComments: 'true'
SortIncludes: 'false'
SpaceAfterCStyleCast: 'true'
SpaceBeforeAssignmentOperators: 'true'
SpaceBeforeParens: ControlStatements
SpaceInEmptyParentheses: 'false'
SpacesBeforeTrailingComments: '1'
SpacesInCStyleCastParentheses: 'false'
SpacesInParentheses: 'false'
SpacesInSquareBrackets: 'false'
TabWidth: '8'
UseTab: Never
...

508
firmware/asdf/test/test_asdf.c Normal file
View File

@ -0,0 +1,508 @@
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "unity.h"
#include "asdf.h"
#include "asdf_ascii.h"
#include "asdf_modifiers.h"
#include "asdf_keymaps.h"
#include "asdf_buffer.h"
#include "asdf_repeat.h"
#define A 'a'
#define B 'b'
#define TEST_STRING "abcdefghijklmnop"
#define NUM_REPEATS (ASDF_KEYCODE_BUFFER_SIZE - 2)
#define TESTMAP(row, col, mapname, mapname2) \
do { \
asdf_keycode_t expected = mapname##_matrix[(row)][(col)]; \
asdf_keycode_t result = asdf_keymaps_get_code((row), (col), MOD_##mapname2##_MAP); \
TEST_ASSERT_EQUAL_INT(expected, result); \
} while (0);
#define TESTPLAIN(row, col, n) TESTMAP((row), (col), PLAIN, n)
#define TESTSHIFT(row, col, n) TESTMAP((row), (col), SHIFT, n)
#define TESTCAPS(row, col, n) TESTMAP((row), (col), CAPS, n)
#define TESTCTRL(row, col, n) TESTMAP((row), (col), CTRL, n)
typedef asdf_keycode_t keycode_matrix_t[ASDF_NUM_ROWS][ASDF_NUM_COLS];
const char test_string[] = TEST_STRING;
const asdf_keycode_t key_a = A;
const asdf_keycode_t key_b = B;
typedef struct {
int32_t row;
int32_t col;
} coord_t;
static const keycode_matrix_t PLAIN_matrix = ASCII_PLAIN_MAP;
static const keycode_matrix_t SHIFT_matrix = ASCII_SHIFT_MAP;
static const keycode_matrix_t CAPS_matrix = ASCII_CAPS_MAP;
static const keycode_matrix_t CTRL_matrix = ASCII_CTRL_MAP;
static uint32_t key_matrix[ASDF_NUM_ROWS];
void setUp(void)
{
asdf_buffer_init();
asdf_init();
// initialize simulated key matrix
for (uint32_t i = 0; i < ASDF_NUM_ROWS; i++) {
key_matrix[i] = 0;
}
}
void tearDown(void) {}
coord_t *find_code(asdf_keycode_t code)
{
uint32_t done = 0;
static coord_t location = { .row = -1, .col = -1 };
for (uint32_t row = 0; !done && (row < ASDF_NUM_ROWS); row++) {
for (uint32_t col = 0; !done && (col < ASDF_NUM_COLS); col++) {
if (PLAIN_matrix[row][col] == code) {
done = 1;
location.row = row;
location.col = col;
}
}
}
return &location;
}
asdf_keycode_t shifted(asdf_keycode_t code)
{
coord_t *location = find_code(code);
return SHIFT_matrix[location->row][location->col];
}
asdf_keycode_t caps(asdf_keycode_t code)
{
coord_t *xy = find_code(code);
return CAPS_matrix[xy->row][xy->col];
}
asdf_keycode_t ctrl(asdf_keycode_t code)
{
coord_t *xy = find_code(code);
return CTRL_matrix[xy->row][xy->col];
}
void keyscan_delay(int32_t ticks)
{
for (; ticks; ticks--) {
asdf_keyscan();
}
}
void press_no_debounce(asdf_keycode_t code)
{
coord_t *location = find_code(code);
key_matrix[location->row] |= (1 << location->col);
}
void release_no_debounce(asdf_keycode_t code)
{
coord_t *location = find_code(code);
key_matrix[location->row] &= ~(1 << location->col);
}
void press(asdf_keycode_t code)
{
press_no_debounce(code);
keyscan_delay(ASDF_DEBOUNCE_TIME_MS);
}
void release(asdf_keycode_t code)
{
release_no_debounce(code);
keyscan_delay(ASDF_DEBOUNCE_TIME_MS);
}
asdf_cols_t asdf_arch_read_row(uint8_t row)
{
return key_matrix[row];
}
// No repsonse to a keypress before it is debounced.
void pressing_a_gives_nothing_before_debounce(void)
{
press_no_debounce(key_a);
// no keypress after only ASDF_DEBOUNCE_TIME_MS -1 ticks (not yet debounced):
keyscan_delay(ASDF_DEBOUNCE_TIME_MS - 1);
TEST_ASSERT_EQUAL_INT32(ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// pressing 'A' gives 'a'
void pressing_a_gives_a(void)
{
press_no_debounce(key_a);
// no keypress after only ASDF_DEBOUNCE_TIME_MS -1 ticks (not yet debounced):
keyscan_delay(ASDF_DEBOUNCE_TIME_MS - 1);
TEST_ASSERT_EQUAL_INT32(ASDF_INVALID_CODE, (int32_t) asdf_get_code());
// allow the key to finish debounce
keyscan_delay(1);
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (int32_t) asdf_get_code());
// no more codes in the buffer.
TEST_ASSERT_EQUAL_INT32(ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// pressing SHIFT+A gives 'A'
void pressing_shift_a_gives_shifted_a(void)
{
press(ACTION_SHIFT);
press(key_a);
TEST_ASSERT_EQUAL_INT32((int32_t) shifted(key_a), (int32_t) asdf_get_code());
}
// pressing CAPS+A gives 'A'
void pressing_caps_a_gives_caps_a(void)
{
press(ACTION_CAPS);
release(ACTION_CAPS);
press(key_a);
TEST_ASSERT_EQUAL_INT32((int32_t) caps(key_a), (int32_t) asdf_get_code());
}
// pressing CTRL+A gives 0x01 (Ctrl-A)
void pressing_ctrl_a_gives_ctrl_a(void)
{
press(ACTION_CTRL);
press(key_a);
TEST_ASSERT_EQUAL_INT32((int32_t) ctrl(key_a), (int32_t) asdf_get_code());
}
// pressing REPT+A repeats 'a'
void pressing_rept_a_repeats_a(void)
{
press(ACTION_REPEAT);
press(key_a);
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
// hold "a" for NUM_REPEATS repeat cycles:
keyscan_delay(NUM_REPEATS * ASDF_REPEAT_TIME_MS);
for (int i = 0; i < NUM_REPEATS; i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
}
// and verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// pressing REPT+SHIFT+A repeats 'A'
void pressing_shift_rept_a_repeats_shifted_a(void)
{
press(ACTION_REPEAT);
press(ACTION_SHIFT);
press(key_a);
TEST_ASSERT_EQUAL_INT32((int32_t) shifted(key_a), (uint32_t) asdf_get_code());
// hold "a" for NUM_REPEATS repeat cycles:
keyscan_delay(NUM_REPEATS * ASDF_REPEAT_TIME_MS);
for (int i = 0; i < NUM_REPEATS; i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) shifted(key_a), (uint32_t) asdf_get_code());
}
// and verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// pressing REPT+CAPS+A repeats 'A'
void pressing_caps_rept_a_repeats_caps_a(void)
{
press(ACTION_REPEAT);
press(ACTION_CAPS);
press(key_a);
TEST_ASSERT_EQUAL_INT32((int32_t) caps(key_a), (uint32_t) asdf_get_code());
// hold "a" for NUM_REPEATS repeat cycles:
keyscan_delay(NUM_REPEATS * ASDF_REPEAT_TIME_MS);
for (int i = 0; i < NUM_REPEATS; i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) caps(key_a), (uint32_t) asdf_get_code());
}
// and verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// pressing REPT+CTRL+A repeats CTRL-A
void pressing_ctrl_rept_a_repeats_ctrl_a(void)
{
press(ACTION_REPEAT);
press(ACTION_CTRL);
press(key_a);
TEST_ASSERT_EQUAL_INT32((int32_t) ctrl(key_a), (uint32_t) asdf_get_code());
// hold "a" for NUM_REPEATS repeat cycles:
keyscan_delay(NUM_REPEATS * ASDF_REPEAT_TIME_MS);
for (int i = 0; i < NUM_REPEATS + 1; i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) ctrl(key_a), (uint32_t) asdf_get_code());
}
// and verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// pressing and holding 'A' autorepeats 'A'
void holding_a_autorepeats_a(void)
{
press(key_a);
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
// hold "a" for NUM_REPEATS repeat cycles:
keyscan_delay(ASDF_AUTOREPEAT_TIME_MS);
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
// and verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// pressing and holding 'A' autorepeats 'A'
void holding_a_autorepeats_slow_then_fast(void)
{
press(key_a);
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
// hold "a" for NUM_REPEATS repeat cycles:
keyscan_delay(ASDF_AUTOREPEAT_TIME_MS);
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
// hold "a" for NUM_REPEATS repeat cycles:
keyscan_delay(NUM_REPEATS * ASDF_REPEAT_TIME_MS);
for (int i = 0; i < NUM_REPEATS; i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
}
// and verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// pressing and holding 'A' and 'B' within less than debounce interval
// eventually returns 'A' then 'B'
void pressing_a_then_b_before_debounce_gives_a_then_b(void)
{
press_no_debounce(key_a);
// press B very quickly after a
keyscan_delay(1);
press(key_b);
// first get back A
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
// next get back B
TEST_ASSERT_EQUAL_INT32((int32_t) key_b, (uint32_t) asdf_get_code());
// and then verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// pressing and holding a series of keys (up to buffer size) in rapid
// succession, allowing each key to debounce, before sending the next, sends all
// the keys in order. (n-key rollover)
void test_key_sequence_nkro(void)
{
for (int i = 0; i < (int32_t) strlen(test_string); i++) {
press((asdf_keycode_t) test_string[i]);
}
for (int i = 0; i < (int32_t) strlen(test_string); i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) test_string[i], (int32_t) asdf_get_code());
}
// and then verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// pressing and holding a series of keys (up to buffer size) in rapid succession
// without waiting for prior keys to debounce, eventually debounces and sends
// all the keys in order. (n-key rollover)
void test_key_sequence_nkro_simultaneous_debounce(void)
{
for (int i = 0; i < (int32_t) strlen(test_string); i++) {
press_no_debounce((asdf_keycode_t) test_string[i]);
keyscan_delay(1);
}
// several keys are already debounced, but now make sure they all are:
keyscan_delay(ASDF_DEBOUNCE_TIME_MS);
for (int i = 0; i < (int32_t) strlen(test_string); i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) test_string[i], (int32_t) asdf_get_code());
}
// and then verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// holding 'A' then pressing 'B' before autorepeat interval and holding 'B' gives 'A', then repeats
// 'B'
void holding_a_briefly_then_holding_b_gives_a_and_repeats_b(void)
{
press(key_a);
keyscan_delay(ASDF_AUTOREPEAT_TIME_MS / 2);
press(key_b);
// hold "a" and "b" for autorepeat delay:
keyscan_delay(ASDF_AUTOREPEAT_TIME_MS);
// hold "a" and "b" for NUM_REPEATS repeat cycles:
keyscan_delay(NUM_REPEATS * ASDF_REPEAT_TIME_MS);
// should get "a" back, then "b"
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
TEST_ASSERT_EQUAL_INT32((int32_t) key_b, (uint32_t) asdf_get_code());
// now get back NUM_REEPEATS repetitions of "b"
for (int i = 0; i < NUM_REPEATS; i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) key_b, (uint32_t) asdf_get_code());
}
// and then verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// holding 'B' while repeating 'A' starts autorepeat delay, then starts repeating 'B'
void holding_a_then_holding_b_autorepeats_a_then_autorepeats_b(void)
{
press(key_a);
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
// hold "a" for AUTOREPEAT delay
keyscan_delay(ASDF_AUTOREPEAT_TIME_MS);
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
// hold "a" for NUM_REPEATS repeat cycles:
keyscan_delay(NUM_REPEATS * ASDF_REPEAT_TIME_MS);
// empty the buffer to make room for 'B'
for (int i = 0; i < NUM_REPEATS; i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
}
// now press "b" while "a" is autorepeating:
press(key_b);
TEST_ASSERT_EQUAL_INT32((int32_t) key_b, (uint32_t) asdf_get_code());
// hold "a" for autorepeat delay
keyscan_delay(ASDF_AUTOREPEAT_TIME_MS);
TEST_ASSERT_EQUAL_INT32((int32_t) key_b, (uint32_t) asdf_get_code());
// hold "a" for NUM_REPEATS repeat cycles:
keyscan_delay(NUM_REPEATS * ASDF_REPEAT_TIME_MS);
// empty the buffer to make room for 'B'
for (int i = 0; i < NUM_REPEATS; i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) key_b, (uint32_t) asdf_get_code());
}
// and verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
// Pressing and holding 'A' then holding 'B' with repeat key held repeats 'A' then 'B'
void repeating_with_a_then_adding_b_repeats_a_then_repeats_b(void)
{
press(ACTION_REPEAT);
press(key_a);
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
// hold "a" for NUM_REPEATS repeat cycles:
keyscan_delay(NUM_REPEATS * ASDF_REPEAT_TIME_MS);
// empty the buffer to make room for 'B'
for (int i = 0; i < NUM_REPEATS; i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) key_a, (uint32_t) asdf_get_code());
}
// now press "b" while "a" is autorepeating:
press(key_b);
TEST_ASSERT_EQUAL_INT32((int32_t) key_b, (uint32_t) asdf_get_code());
// hold "a" for NUM_REPEATS repeat cycles:
keyscan_delay(NUM_REPEATS * ASDF_REPEAT_TIME_MS);
// empty the buffer to make room for 'B'
for (int i = 0; i < NUM_REPEATS; i++) {
TEST_ASSERT_EQUAL_INT32((int32_t) key_b, (uint32_t) asdf_get_code());
}
// and verify there are no more codes in buffer:
TEST_ASSERT_EQUAL_INT32((int32_t) ASDF_INVALID_CODE, (int32_t) asdf_get_code());
}
int main(void)
{
UNITY_BEGIN();
RUN_TEST(pressing_a_gives_nothing_before_debounce);
RUN_TEST(pressing_a_gives_a);
RUN_TEST(pressing_shift_a_gives_shifted_a);
RUN_TEST(pressing_caps_a_gives_caps_a);
RUN_TEST(pressing_ctrl_a_gives_ctrl_a);
RUN_TEST(pressing_rept_a_repeats_a);
RUN_TEST(pressing_shift_rept_a_repeats_shifted_a);
RUN_TEST(pressing_caps_rept_a_repeats_caps_a);
RUN_TEST(holding_a_autorepeats_a);
RUN_TEST(holding_a_autorepeats_slow_then_fast);
RUN_TEST(pressing_a_then_b_before_debounce_gives_a_then_b);
RUN_TEST(test_key_sequence_nkro);
RUN_TEST(test_key_sequence_nkro_simultaneous_debounce);
RUN_TEST(holding_a_briefly_then_holding_b_gives_a_and_repeats_b);
RUN_TEST(holding_a_then_holding_b_autorepeats_a_then_autorepeats_b);
RUN_TEST(repeating_with_a_then_adding_b_repeats_a_then_repeats_b);
return UNITY_END();
}

201
firmware/asdf/test/test_asdf_buffer.c Normal file
View File

@ -0,0 +1,201 @@
#include <stdio.h>
#include <stdint.h>
#include "unity.h"
#include "asdf.h"
#include "asdf_buffer.h"
#define TEST_VALUE 'a'
#define MAX_BUFFER ASDF_BUFFER_POOL_SIZE
#define HALF_BUFFER (ASDF_BUFFER_POOL_SIZE / 2)
static const char test_string[] = "abcdefghijklmnopqrstuvwxyz1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static const char * const more_strings[] = {
"abcdefghijkl",
"12345",
"ABCDEFG",
"The quick brown",
"We the people",
"+"
};
static asdf_buffer_handle_t handle;
void setUp(void)
{
asdf_buffer_init();
handle = asdf_buffer_new(MAX_BUFFER);
}
void tearDown(void) {}
// allocating first buffer returns handle 0
void test_allocating_first_buffer_returns_handle_0(void)
{
TEST_ASSERT_EQUAL_INT32(0, (int32_t) handle);
}
// allocating second buffer returns handle 1
void test_allocating_second_buffer_returns_handle_1(void)
{
asdf_buffer_handle_t handle_1;
asdf_buffer_handle_t handle_2;
asdf_buffer_init();
handle_1 = asdf_buffer_new(HALF_BUFFER);
TEST_ASSERT_EQUAL_INT32(0, (int32_t) handle_1);
handle_2 = asdf_buffer_new(HALF_BUFFER);
TEST_ASSERT_EQUAL_INT32(1, (int32_t) handle_2);
}
// allocating more buffers than available returns invalid buffer handle
void test_allocating_too_many_buffers_returns_invalid(void)
{
asdf_buffer_init();
for (int i = 0; i <= ASDF_BUFFER_NUM_HANDLES; i++) {
handle = asdf_buffer_new(1);
}
TEST_ASSERT_EQUAL_INT32(ASDF_BUFFER_INVALID, (int32_t) handle);
}
// all of the alloted handles can be allocated
void test_all_handles_are_allocated(void)
{
asdf_buffer_init();
for (int i = 0; i < ASDF_BUFFER_NUM_HANDLES; i++) {
handle = asdf_buffer_new(1);
TEST_ASSERT_EQUAL_INT32(i, (int32_t) handle);
}
// and one more should be an invalid handle:
handle = asdf_buffer_new(1);
TEST_ASSERT_EQUAL_INT32(ASDF_BUFFER_INVALID, (int32_t) handle);
}
// allocating more space than available returns invalid buffer handle
void test_allocating_too_much_space_returns_invalid(void)
{
asdf_buffer_init();
handle = asdf_buffer_new(MAX_BUFFER + 1);
TEST_ASSERT_EQUAL_INT32(ASDF_BUFFER_INVALID, (int32_t) handle);
}
// get from an invalid buffer returns invalid code
void test_get_from_invalid_handle_returns_invalid_code(void)
{
TEST_ASSERT_EQUAL_INT32(ASDF_INVALID_CODE, (int32_t) asdf_buffer_get(ASDF_BUFFER_INVALID));
}
void test_get_from_unallocated_handle_returns_invalid_code(void)
{
asdf_keycode_t code = asdf_buffer_get(ASDF_BUFFER_NUM_HANDLES-1);
TEST_ASSERT_EQUAL_INT32(ASDF_INVALID_CODE, (int32_t) code);
}
// retrieving from empty queue gives invalid code
void get_from_empty_queue_returns_error(void)
{
TEST_ASSERT_EQUAL_INT32(ASDF_INVALID_CODE, (int32_t) asdf_buffer_get(handle));
}
// adding and retrieving give the same code back.
void sending_code_and_retrieve_returns_same_code(void)
{
asdf_buffer_put(handle, TEST_VALUE);
TEST_ASSERT_EQUAL_INT32(TEST_VALUE, (int32_t) asdf_buffer_get(handle));
}
// adding then fetching a string of codes one-by-one gives the same string back in order
void test_adding_and_retrieving_string_one_by_one(void)
{
for (int i = 0; i < (int) sizeof(test_string); i++) {
asdf_buffer_put(handle, (asdf_keycode_t) test_string[i]);
TEST_ASSERT_EQUAL_INT32((int32_t) test_string[i], (int32_t) asdf_buffer_get(handle));
}
}
// Filling the buffer first, then retrieving the characters from the buffer
// should return the same string.
void test_fill_buffer_then_retrieve_string(void)
{
for (int sent = 0; sent < MAX_BUFFER; sent++) {
asdf_buffer_put(handle, (asdf_keycode_t) test_string[sent]);
}
for (int received = 0; received < MAX_BUFFER; received++) {
int32_t code = (int32_t) asdf_buffer_get(handle);
TEST_ASSERT_EQUAL_INT32((int32_t) test_string[received],code);
}
// assert that next code request returns invalid code:
TEST_ASSERT_EQUAL_INT32(ASDF_INVALID_CODE, (int32_t) asdf_buffer_get(handle));
}
// adding a string longer than the buffer length gives the first BUFFER_LENGTH
// characters back, quietly dropping the overflow.
void test_overfilling_buffer_and_retrieve_drops_overflow(void)
{
// send the entire test string to overflow the buffer.
for (int i = 0; i < (int) sizeof(test_string); i++) {
asdf_buffer_put(handle, (asdf_keycode_t) test_string[i]);
}
// read until invalid character is received, testing that each character is
// correct.
for (int i = 0; i < MAX_BUFFER; i++) {
asdf_keycode_t code = asdf_buffer_get(handle);
TEST_ASSERT_EQUAL_INT32((int32_t) test_string[i], (int32_t) code);
}
// the next code request returns invalid code:
TEST_ASSERT_EQUAL_INT32(ASDF_INVALID_CODE, (int32_t) asdf_buffer_get(handle));
}
// with an alternating pattern of adding and retrieving codes, the sent code string matches the retrieved string.
void test_send_get_multiple_strings(void)
{
for (int i = 0; '+' != more_strings[i][0]; i++) {
for (const char * chrptr = (const char *) &more_strings[i][0]; *chrptr; chrptr++) {
asdf_buffer_put(handle, (asdf_keycode_t) *chrptr);
}
// read until invalid character is received, testing that each character is
// correct.
for (const char * chrptr = (const char *) &more_strings[i][0]; *chrptr; chrptr++) {
asdf_keycode_t code = asdf_buffer_get(handle);
TEST_ASSERT_EQUAL_INT32((int32_t) *chrptr, (int32_t) code);
}
// the next code request returns invalid code:
TEST_ASSERT_EQUAL_INT32(ASDF_INVALID_CODE, (int32_t) asdf_buffer_get(handle));
}
}
int main(void)
{
UNITY_BEGIN();
RUN_TEST(test_allocating_first_buffer_returns_handle_0);
RUN_TEST(test_allocating_second_buffer_returns_handle_1);
RUN_TEST(test_allocating_too_many_buffers_returns_invalid);
RUN_TEST(test_all_handles_are_allocated);
RUN_TEST(test_allocating_too_much_space_returns_invalid);
RUN_TEST(test_get_from_invalid_handle_returns_invalid_code);
RUN_TEST(test_get_from_unallocated_handle_returns_invalid_code);
RUN_TEST(get_from_empty_queue_returns_error);
RUN_TEST(sending_code_and_retrieve_returns_same_code);
RUN_TEST(test_adding_and_retrieving_string_one_by_one);
RUN_TEST(test_fill_buffer_then_retrieve_string);
RUN_TEST(test_overfilling_buffer_and_retrieve_drops_overflow);
RUN_TEST(test_send_get_multiple_strings);
return UNITY_END();
}

118
firmware/asdf/test/test_asdf_keymaps.c Normal file
View File

@ -0,0 +1,118 @@
#include <stdint.h>
#include "unity.h"
#include "asdf.h"
#include "asdf_ascii.h"
#include "asdf_modifiers.h"
#include "asdf_keymaps.h"
#define TESTALPHA 'a'
#define TESTNUM '2'
#define TESTMAP(row, col, mapname, mapname2) \
do { \
asdf_keycode_t expected = mapname##_matrix[(row)][(col)]; \
asdf_keycode_t result = asdf_keymaps_get_code((row), (col), MOD_ ## mapname2 ## _MAP); \
TEST_ASSERT_EQUAL_INT(expected, result); \
} while (0);
#define TEST_VALID_CODE(position) do { \
coord_t pos = position; \
TEST_ASSERT_FALSE(pos.row == -1); \
TEST_ASSERT_FALSE(pos.col == -1); \
} while (0);
#define TESTPLAIN(row, col, n) TESTMAP((row), (col), PLAIN, n)
#define TESTSHIFT(row, col, n) TESTMAP((row), (col), SHIFT, n)
#define TESTCAPS(row, col, n) TESTMAP((row), (col), CAPS, n)
#define TESTCTRL(row, col, n) TESTMAP((row), (col), CTRL, n)
typedef asdf_keycode_t keycode_matrix_t[ASDF_NUM_ROWS][ASDF_NUM_COLS];
typedef struct {
int32_t row;
int32_t col;
} coord_t;
static const keycode_matrix_t PLAIN_matrix = ASCII_PLAIN_MAP;
static const keycode_matrix_t SHIFT_matrix = ASCII_SHIFT_MAP;
static const keycode_matrix_t CAPS_matrix = ASCII_CAPS_MAP;
static const keycode_matrix_t CTRL_matrix = ASCII_CTRL_MAP;
static coord_t alpha_sample;
static coord_t num_sample;
coord_t *find_code(asdf_keycode_t code)
{
uint32_t done = 0;
static coord_t location = { .row = -1, .col = -1 };
for (uint32_t row = 0; !done && (row < ASDF_NUM_ROWS); row++) {
for (uint32_t col = 0; !done && (col < ASDF_NUM_COLS); col++) {
if (PLAIN_matrix[row][col] == code) {
done = 1;
location.row = row;
location.col = col;
}
}
}
return &location;
}
void setUp(void)
{
coord_t *temp;
asdf_keymaps_init();
temp = find_code(TESTALPHA);
alpha_sample = *temp;
temp = find_code(TESTNUM);
num_sample = *temp;
}
void tearDown(void) {}
void test_chars_are_in_map(void) {
TEST_VALID_CODE(alpha_sample);
TEST_VALID_CODE(num_sample);
}
void plain_map_gives_plain_values(void)
{
TESTPLAIN(alpha_sample.row, alpha_sample.col, PLAIN);
TESTPLAIN(num_sample.row, num_sample.col, PLAIN);
}
void shift_map_gives_shift_values(void)
{
TESTSHIFT(alpha_sample.row, alpha_sample.col, SHIFT);
TESTSHIFT(num_sample.row, num_sample.col, SHIFT);
}
void caps_map_gives_caps_values(void)
{
TESTCAPS(alpha_sample.row, alpha_sample.col, CAPS);
TESTCAPS(num_sample.row, num_sample.col, CAPS);
}
void ctrl_map_gives_ctrl_values(void)
{
TESTCTRL(alpha_sample.row, alpha_sample.col, CTRL);
TESTCTRL(num_sample.row, num_sample.col, CTRL);
}
int main(void)
{
UNITY_BEGIN();
RUN_TEST(test_chars_are_in_map);
RUN_TEST(plain_map_gives_plain_values);
RUN_TEST(shift_map_gives_shift_values);
RUN_TEST(caps_map_gives_caps_values);
RUN_TEST(ctrl_map_gives_ctrl_values);
return UNITY_END();
}

315
firmware/asdf/test/test_asdf_modifiers.c Normal file
View File

@ -0,0 +1,315 @@
#include <stdint.h>
#include "unity.h"
#include "asdf_modifiers.h"
#define TESTMAP(a) \
do { \
uint32_t map = (uint32_t) asdf_modifier_index(); \
TEST_ASSERT_EQUAL_INT((a), map); \
} while (0);
void setUp(void)
{
asdf_modifiers_init();
}
void tearDown(void) {}
// initial map is plain
void initial_map_is_plain(void)
{
TESTMAP(MOD_PLAIN_MAP);
}
// SHIFT gives shift map
void shift_gives_shiftmap(void)
{
asdf_modifier_shift_activate();
TESTMAP(MOD_SHIFT_MAP);
}
// SHIFT press & release gives plain map
void shift_and_release_gives_plain(void)
{
asdf_modifier_shift_activate();
TESTMAP(MOD_SHIFT_MAP);
asdf_modifier_shift_deactivate();
TESTMAP(MOD_PLAIN_MAP);
}
// CAPSLOCK gives caps map
void capslock_gives_caps(void)
{
asdf_modifier_capslock_activate();
TESTMAP(MOD_CAPS_MAP);
}
// CAPLOCK press and release gives caps map
void capslock_and_release_gives_caps(void)
{
asdf_modifier_capslock_activate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_CAPS_MAP);
}
// CAPS-release-CAPS give plain
void caps_release_caps_gives_plain(void)
{
asdf_modifier_capslock_activate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_capslock_activate();
TESTMAP(MOD_PLAIN_MAP);
}
// CAPS-release-CAPS-release will first activate CAPS mode then deactivation,
// resulting in final plain map.
void caps_release_caps_release_gives_plain(void)
{
asdf_modifier_capslock_activate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_capslock_activate();
TESTMAP(MOD_PLAIN_MAP);
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_PLAIN_MAP);
}
// If SHIFT and CAPS are activated, the SHIFT map results
void shift_and_caps_gives_shift(void)
{
asdf_modifier_capslock_activate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_shift_activate();
TESTMAP(MOD_SHIFT_MAP);
}
// IF CAPS map is active, pressing and releasing SHIFT reverts to CAPS
void caps_shift_unshift_gives_caps(void)
{
asdf_modifier_capslock_activate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_shift_activate();
TESTMAP(MOD_SHIFT_MAP);
asdf_modifier_shift_deactivate();
TESTMAP(MOD_CAPS_MAP);
}
// Capslock and SHiftlock gives SHIFT
void capslock_shiftlock_gives_shift(void)
{
asdf_modifier_capslock_activate();
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_shiftlock_activate();
asdf_modifier_shiftlock_deactivate();
TESTMAP(MOD_SHIFT_MAP);
}
// Pressing CAPSLOCK and SHIFTLOCK, then CAPSLOCK again gives shift map.
void capslock_shiftlock_capslock_gives_shift(void)
{
asdf_modifier_capslock_activate();
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_shiftlock_activate();
asdf_modifier_shiftlock_deactivate();
TESTMAP(MOD_SHIFT_MAP);
asdf_modifier_capslock_activate();
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_SHIFT_MAP);
}
// Pressing CAPSLOCK and SHIFTLOCK, then press and releast SHIFT (to deactivate
// the shiftlock) again gives shift map.
void capslock_shiftlock_shift_gives_caps(void)
{
asdf_modifier_capslock_activate();
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_CAPS_MAP);
asdf_modifier_shiftlock_activate();
asdf_modifier_shiftlock_deactivate();
TESTMAP(MOD_SHIFT_MAP);
asdf_modifier_shift_activate();
asdf_modifier_shift_deactivate();
TESTMAP(MOD_CAPS_MAP);
}
// SHIFTLOCK press gives shift map
void shiftlock_gives_shift(void)
{
asdf_modifier_shiftlock_activate();
TESTMAP(MOD_SHIFT_MAP);
}
// SHIFTLOCK press and release gives shift map
void shiftlock_and_release_gives_shift(void)
{
asdf_modifier_shiftlock_activate();
asdf_modifier_shiftlock_deactivate();
TESTMAP(MOD_SHIFT_MAP);
}
// SHIFTLOCK and SHIFT gives shift map
void shiftlock_shift_gives_shift(void)
{
asdf_modifier_shiftlock_activate();
asdf_modifier_shiftlock_deactivate();
TESTMAP(MOD_SHIFT_MAP);
asdf_modifier_shift_activate();
TESTMAP(MOD_SHIFT_MAP);
}
// SHIFTLOCK and SHIFT press and release gives plain map
void shiftlock_shift_release_gives_plain(void)
{
asdf_modifier_shiftlock_activate();
asdf_modifier_shiftlock_deactivate();
TESTMAP(MOD_SHIFT_MAP);
asdf_modifier_shift_activate();
asdf_modifier_shift_deactivate();
TESTMAP(MOD_PLAIN_MAP);
}
// CTRL gives ctrl map
void ctrl_gives_ctrl_map(void)
{
asdf_modifier_ctrl_activate();
TESTMAP(MOD_CTRL_MAP);
}
// CTRL press and release gives plain map
void ctrl_release_gives_plain_map(void)
{
asdf_modifier_ctrl_activate();
TESTMAP(MOD_CTRL_MAP);
asdf_modifier_ctrl_activate();
asdf_modifier_ctrl_deactivate();
TESTMAP(MOD_PLAIN_MAP);
}
// SHIFT + CTRL is ctrl map
void ctrl_shift_gives_ctrl_map(void)
{
asdf_modifier_ctrl_activate();
TESTMAP(MOD_CTRL_MAP);
asdf_modifier_shift_activate();
TESTMAP(MOD_CTRL_MAP);
}
// CAPSLOCK and CTRL is ctrl map
void ctrl_caps_gives_ctrl_map(void)
{
asdf_modifier_ctrl_activate();
TESTMAP(MOD_CTRL_MAP);
asdf_modifier_capslock_activate();
TESTMAP(MOD_CTRL_MAP);
}
// SHIFTLOCK and CTRL is ctrl map
void ctrl_shiftlock_gives_ctrl_map(void)
{
asdf_modifier_ctrl_activate();
TESTMAP(MOD_CTRL_MAP);
asdf_modifier_shiftlock_activate();
TESTMAP(MOD_CTRL_MAP);
}
void ctrl_double_caps_returns_to_ctrl_map(void)
{
asdf_modifier_ctrl_activate();
TESTMAP(MOD_CTRL_MAP);
asdf_modifier_capslock_activate();
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_CTRL_MAP);
asdf_modifier_capslock_activate();
asdf_modifier_capslock_deactivate();
TESTMAP(MOD_CTRL_MAP);
}
void ctrl_double_shiftlock_returns_to_ctrl_map(void)
{
asdf_modifier_ctrl_activate();
TESTMAP(MOD_CTRL_MAP);
asdf_modifier_shiftlock_activate();
asdf_modifier_shiftlock_deactivate();
TESTMAP(MOD_CTRL_MAP);
asdf_modifier_shiftlock_activate();
asdf_modifier_shiftlock_deactivate();
TESTMAP(MOD_CTRL_MAP);
}
int main(void)
{
UNITY_BEGIN();
RUN_TEST(initial_map_is_plain);
RUN_TEST(shift_gives_shiftmap);
RUN_TEST(shift_and_release_gives_plain);
RUN_TEST(capslock_gives_caps);
RUN_TEST(capslock_and_release_gives_caps);
RUN_TEST(caps_release_caps_gives_plain);
RUN_TEST(caps_release_caps_release_gives_plain);
RUN_TEST(shift_and_caps_gives_shift);
RUN_TEST(caps_shift_unshift_gives_caps);
RUN_TEST(capslock_shiftlock_gives_shift);
RUN_TEST(capslock_shiftlock_capslock_gives_shift);
RUN_TEST(capslock_shiftlock_shift_gives_caps);
RUN_TEST(shiftlock_gives_shift);
RUN_TEST(shiftlock_and_release_gives_shift);
RUN_TEST(shiftlock_shift_gives_shift);
RUN_TEST(shiftlock_shift_release_gives_plain);
RUN_TEST(ctrl_gives_ctrl_map);
RUN_TEST(ctrl_release_gives_plain_map);
RUN_TEST(ctrl_shift_gives_ctrl_map);
RUN_TEST(ctrl_caps_gives_ctrl_map);
RUN_TEST(ctrl_shiftlock_gives_ctrl_map);
RUN_TEST(ctrl_double_caps_returns_to_ctrl_map);
RUN_TEST(ctrl_double_shiftlock_returns_to_ctrl_map);
// toggle shiftlock_mode switches the shiftlock behavior to toggle_mode
// calling toggle_shiftlock_mode twice leaves shiftlock behavior in hold mode
// calling toggle_shiftlock_mode three times leaves shiftlock behavior in toggle mode
return UNITY_END();
}

448
firmware/asdf/test/test_asdf_repeat.c Normal file
View File

@ -0,0 +1,448 @@
#include <stdio.h>
#include <stdint.h>
#include "unity.h"
#include "asdf_repeat.h"
#define REPEAT_TIMED_OUT 10000
#define NUM_REPETITIONS 10
uint32_t count_repeat_ticks(uint32_t timeout)
{
uint32_t count = 0;
uint32_t test;
do {
test = asdf_repeat();
count++;
} while (!test && count < timeout);
return count;
}
void setUp(void)
{
asdf_repeat_init();
}
void tearDown(void) {}
// On initialization, autorepeat should be enabled by default.
void test_asdf_repeat_init_resets_to_autorepeat_default(void)
{
uint32_t delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
}
// If autorepeat is turned off, then holding down a simulated key should not
// cause a repeat event.
void test_asdf_repeat_no_repeat_if_auto_turned_off(void)
{
uint32_t delay;
asdf_repeat_auto_off();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(REPEAT_TIMED_OUT, delay);
}
// If autorepeat is turned on, then holding down a simulated key should cause a
// repeat event after the autorepeat interval.
void test_asdf_repeat_autorepeat_if_auto_turned_on(void)
{
uint32_t delay;
asdf_repeat_auto_off();
asdf_repeat_auto_on();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
}
// After the autorepeat interval, subsequent repeat events should occur at the
// regular repeat interval.
void test_asf_repeat_autorepeat_fast_repeat_after_delay(void)
{
uint32_t delay;
// wait out the autorepeat delay
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
// now verify the next repeat interval is short:
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS, delay);
}
// If autorepeat is turned on, then holding down a key should cause a repeat
// event at the autorepeat interval. This should be true if autorepeat was
// previously off, or if it was already on, so test both cases here.
void test_asdf_repeat_auto_repeat_if_auto_turned_on(void)
{
uint32_t delay;
asdf_repeat_auto_on();
asdf_repeat_auto_on();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
asdf_repeat_auto_off();
asdf_repeat_auto_on();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
}
// When in autorepeat mode, calling asdf_repeat_reset_count() should reset the
// repeat timer to the autorepeat interval.
void test_asdf_repeat_reset_count_works_in_autorepeat_mode(void)
{
uint32_t delay;
// wait 1/2 of autorepeat time and release a key
delay = count_repeat_ticks(ASDF_AUTOREPEAT_TIME_MS / 2);
TEST_ASSERT_EQUAL_INT((ASDF_AUTOREPEAT_TIME_MS / 2), delay);
asdf_repeat_reset_count();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
}
// When in repeat mode (repeat key held down), calling asdf_repeat_reset_count()
// should reset the repeat timer to the repeat interval.
void test_asdf_repeat_reset_count_works_in_repeat_mode(void)
{
uint32_t delay;
// wait 1/2 of autorepeat time and release a key
asdf_repeat_activate();
delay = count_repeat_ticks(ASDF_REPEAT_TIME_MS / 2);
TEST_ASSERT_EQUAL_INT((ASDF_REPEAT_TIME_MS / 2), delay);
asdf_repeat_reset_count();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS, delay);
}
// When Autoreat is enabled, activating repeat mode (pressing the repeat key)
// should cause repeat events to occur at the fast repeat rate, skipping the
// autorepeat interval.
void test_asdf_repeat_activate_with_auto_on(void)
{
uint32_t delay;
asdf_repeat_auto_on();
asdf_repeat_activate();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS, delay);
}
// When Autoreat is off, activating repeat mode (pressing the repeat key)
// should cause repeat events to occur at the fast repeat rate
void test_asdf_repeat_activate_with_auto_off(void)
{
uint32_t delay;
asdf_repeat_auto_off();
asdf_repeat_activate();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS, delay);
}
// If autorepeat is disabled, then activating and deactivating repeat mode
// (pressing and releasing the repeat key) should return to the autorepeat
// disabled mode.
void test_asdf_repeat_deactivate_returns_to_baseline_no_repeat(void)
{
uint32_t delay;
asdf_repeat_auto_off();
// simulate a brief REPEAT key press (3 repeat cycles)
asdf_repeat_activate();
delay = 0;
for (uint32_t i = 0; i < NUM_REPETITIONS; i++) {
delay += count_repeat_ticks(REPEAT_TIMED_OUT);
}
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS * NUM_REPETITIONS, delay);
asdf_repeat_deactivate();
// now that repeat is deactivated, we should time out before hitting a repeat
// event:
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(REPEAT_TIMED_OUT, delay);
}
// If autorepeat is enabled, then activating and deactivating repeat mode
// (pressing and releasing the repeat key) should return to the autorepeat
// enabled mode.
void test_asdf_repeat_deactivate_returns_to_baseline_autorepeat(void)
{
uint32_t delay;
// simulate a brief REPEAT key press (1/2 autorepeat time)
asdf_repeat_activate();
delay = 0;
for (uint32_t i = 0; i < NUM_REPETITIONS; i++) {
delay += count_repeat_ticks(REPEAT_TIMED_OUT);
}
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS * NUM_REPETITIONS, delay);
asdf_repeat_deactivate();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
}
// When Autoreat is enabled, and the autorepeat timer is activated by holding
// down a key, then activating repeat (pressing the repeat key) should skip the
// rest of the autorepeat interval, and cause repeat events to occur at the fast
// repeat rate.
void test_asdf_repeat_repeat_key_circumvents_initial_autorepeat_delay(void)
{
uint32_t delay;
// simulate a brief keypress (1/2 autorepeat time)
delay = count_repeat_ticks(ASDF_AUTOREPEAT_TIME_MS / 2);
TEST_ASSERT_EQUAL_INT((ASDF_AUTOREPEAT_TIME_MS / 2), delay);
// simulate pressing the REPEAT key in the middle of an autorepeat interval
asdf_repeat_activate();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS, delay);
}
// If autorepeat is on, and a key is being held down to start the autorepeat
// interval, then turning off autorepeat mode should prevent the key from
// repeating.
void test_asdf_repeat_turning_off_auto_cancels_autorepeat_delay_in_progress(void)
{
uint32_t delay;
asdf_repeat_auto_on();
// simulate a brief keypress (1/2 autorepeat time)
delay = count_repeat_ticks(ASDF_AUTOREPEAT_TIME_MS / 2);
TEST_ASSERT_EQUAL_INT((ASDF_AUTOREPEAT_TIME_MS / 2), delay);
asdf_repeat_auto_off();
// simulate continued holding down key
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(REPEAT_TIMED_OUT, delay);
}
// If a key is autorepeating (held down until it repeats, without the repeat key
// being held down), then turning off autorepeat mode should stop the key from
// repeating.
void test_asdf_repeat_turning_off_auto_cancels_autorepeating_keypress(void)
{
uint32_t delay;
asdf_repeat_auto_on();
// simulate an autorepeating key. Wait out entire autorepeat delay.
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
// wait NUM_REPETITIONS repeat cycles:
delay = 0;
for (uint32_t i = 0; i < NUM_REPETITIONS; i++) {
delay += count_repeat_ticks(REPEAT_TIMED_OUT);
}
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS * NUM_REPETITIONS, delay);
asdf_repeat_auto_off();
for (delay = 0; !asdf_repeat() && (delay < REPEAT_TIMED_OUT); delay++) {
}
TEST_ASSERT_EQUAL_INT(REPEAT_TIMED_OUT, delay);
}
// If you press the REPEAT key while a key is already autorepeating (i.e., after
// the autorepeat delay interval), then the repeat timing shall not be affected.
void test_asdf_repeat_activate_while_autorepeating_wont_affect_timing(void)
{
uint32_t delay;
asdf_repeat_auto_on();
// simulate an autorepeating key. Wait out entire autorepeat delay.
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
// wait 1/2 fast repeat cycle:
// simulate an autorepeating key. Wait out entire autorepeat delay.
delay = count_repeat_ticks(ASDF_REPEAT_TIME_MS / 2);
TEST_ASSERT_EQUAL_INT((ASDF_REPEAT_TIME_MS / 2), delay);
// turn on repeat mode (press REPEAT key)
asdf_repeat_activate();
// now verify the repeat interval was not affected. Finish the current repeat
// interval
delay += count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS, delay);
}
// If in autorepeat mode and the repeat key is released while a key is
// repeating, the next repeat event should occur after a new autorepeat delay
// interval.
void test_asdf_repeat_deactivate_while_repeating_resets_autorepeat_counter(void)
{
uint32_t delay;
asdf_repeat_auto_on();
asdf_repeat_activate();
// wait NUM_REPETITIONS repeat cycles:
delay = 0;
for (uint32_t i = 0; i < NUM_REPETITIONS; i++) {
delay += count_repeat_ticks(REPEAT_TIMED_OUT);
}
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS * NUM_REPETITIONS, delay);
// releast REPEAT key:
asdf_repeat_deactivate();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
// should have waited entire autorepeat delay interval
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
}
// If autorepeat is disabled and the repeat key is released while a key is
// repeating, then the key should stop repeating.
void test_asdf_repeat_deactivate_while_repeating_stops_repeating(void)
{
uint32_t delay;
asdf_repeat_auto_off();
asdf_repeat_activate();
// wait NUM_REPETITIONS repeat cycles:
delay = 0;
for (uint32_t i = 0; i < NUM_REPETITIONS; i++) {
delay += count_repeat_ticks(REPEAT_TIMED_OUT);
}
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS * NUM_REPETITIONS, delay);
// releast REPEAT key:
asdf_repeat_deactivate();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
// should have waited entire autorepeat delay interval
TEST_ASSERT_EQUAL_INT(REPEAT_TIMED_OUT, delay);
}
// pressing a new value key when REPEAT is active should start repeating right
// away.
void test_asdf_repeat_new_key_while_repeat_active_keeps_repeating(void)
{
uint32_t delay;
asdf_repeat_activate();
// wait NUM_REPETITIONS repeat cycles:
delay = 0;
for (uint32_t i = 0; i < NUM_REPETITIONS; i++) {
delay += count_repeat_ticks(REPEAT_TIMED_OUT);
}
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS * NUM_REPETITIONS, delay);
// simulate half a repeat interval
delay = count_repeat_ticks(ASDF_REPEAT_TIME_MS / 2);
// simulate a new key press:
asdf_repeat_reset_count();
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
// should have waited the key repeat interval
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS, delay);
}
// pressing a new value key when autorepeating should start new autorepeat
// delay.
void test_asdf_repeat_new_key_while_autorepeating_starts_new_autorepeat(void)
{
uint32_t delay;
asdf_repeat_auto_on();
// simulate an autorepeating key. Wait out entire autorepeat delay.
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
// wait NUM_REPETITIONS repeat cycles:
delay = 0;
for (uint32_t i = 0; i < NUM_REPETITIONS; i++) {
delay += count_repeat_ticks(REPEAT_TIMED_OUT);
}
TEST_ASSERT_EQUAL_INT(ASDF_REPEAT_TIME_MS * NUM_REPETITIONS, delay);
// simulate new keypress:
asdf_repeat_reset_count();
// now measure interval until next repeat event.
delay = count_repeat_ticks(REPEAT_TIMED_OUT);
TEST_ASSERT_EQUAL_INT(ASDF_AUTOREPEAT_TIME_MS, delay);
}
int main(void)
{
UNITY_BEGIN();
RUN_TEST(test_asdf_repeat_init_resets_to_autorepeat_default);
RUN_TEST(test_asdf_repeat_no_repeat_if_auto_turned_off);
RUN_TEST(test_asdf_repeat_auto_repeat_if_auto_turned_on);
RUN_TEST(test_asf_repeat_autorepeat_fast_repeat_after_delay);
RUN_TEST(test_asdf_repeat_reset_count_works_in_autorepeat_mode);
RUN_TEST(test_asdf_repeat_reset_count_works_in_repeat_mode);
RUN_TEST(test_asdf_repeat_activate_with_auto_on);
RUN_TEST(test_asdf_repeat_activate_with_auto_off);
RUN_TEST(test_asdf_repeat_deactivate_returns_to_baseline_autorepeat);
RUN_TEST(test_asdf_repeat_deactivate_returns_to_baseline_no_repeat);
RUN_TEST(test_asdf_repeat_repeat_key_circumvents_initial_autorepeat_delay);
RUN_TEST(test_asdf_repeat_activate_while_autorepeating_wont_affect_timing);
RUN_TEST(test_asdf_repeat_turning_off_auto_cancels_autorepeating_keypress);
RUN_TEST(test_asdf_repeat_turning_off_auto_cancels_autorepeat_delay_in_progress);
RUN_TEST(test_asdf_repeat_deactivate_while_repeating_resets_autorepeat_counter);
RUN_TEST(test_asdf_repeat_deactivate_while_repeating_stops_repeating);
RUN_TEST(test_asdf_repeat_new_key_while_repeat_active_keeps_repeating);
RUN_TEST(test_asdf_repeat_new_key_while_autorepeating_starts_new_autorepeat);
return UNITY_END();
}

118
firmware/asdf/test/unity/auto/colour_prompt.rb Normal file
View File

@ -0,0 +1,118 @@
# ==========================================
# Unity Project - A Test Framework for C
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
# [Released under MIT License. Please refer to license.txt for details]
# ==========================================
if RUBY_PLATFORM =~ /(win|w)32$/
begin
require 'Win32API'
rescue LoadError
puts 'ERROR! "Win32API" library not found'
puts '"Win32API" is required for colour on a windows machine'
puts ' try => "gem install Win32API" on the command line'
puts
end
# puts
# puts 'Windows Environment Detected...'
# puts 'Win32API Library Found.'
# puts
end
class ColourCommandLine
def initialize
return unless RUBY_PLATFORM =~ /(win|w)32$/
get_std_handle = Win32API.new('kernel32', 'GetStdHandle', ['L'], 'L')
@set_console_txt_attrb =
Win32API.new('kernel32', 'SetConsoleTextAttribute', %w[L N], 'I')
@hout = get_std_handle.call(-11)
end
def change_to(new_colour)
if RUBY_PLATFORM =~ /(win|w)32$/
@set_console_txt_attrb.call(@hout, win32_colour(new_colour))
else
"\033[30;#{posix_colour(new_colour)};22m"
end
end
def win32_colour(colour)
case colour
when :black then 0
when :dark_blue then 1
when :dark_green then 2
when :dark_cyan then 3
when :dark_red then 4
when :dark_purple then 5
when :dark_yellow, :narrative then 6
when :default_white, :default, :dark_white then 7
when :silver then 8
when :blue then 9
when :green, :success then 10
when :cyan, :output then 11
when :red, :failure then 12
when :purple then 13
when :yellow then 14
when :white then 15
else
0
end
end
def posix_colour(colour)
# ANSI Escape Codes - Foreground colors
# | Code | Color |
# | 39 | Default foreground color |
# | 30 | Black |
# | 31 | Red |
# | 32 | Green |
# | 33 | Yellow |
# | 34 | Blue |
# | 35 | Magenta |
# | 36 | Cyan |
# | 37 | Light gray |
# | 90 | Dark gray |
# | 91 | Light red |
# | 92 | Light green |
# | 93 | Light yellow |
# | 94 | Light blue |
# | 95 | Light magenta |
# | 96 | Light cyan |
# | 97 | White |
case colour
when :black then 30
when :red, :failure then 31
when :green, :success then 32
when :yellow then 33
when :blue, :narrative then 34
when :purple, :magenta then 35
when :cyan, :output then 36
when :white, :default_white then 37
when :default then 39
else
39
end
end
def out_c(mode, colour, str)
case RUBY_PLATFORM
when /(win|w)32$/
change_to(colour)
$stdout.puts str if mode == :puts
$stdout.print str if mode == :print
change_to(:default_white)
else
$stdout.puts("#{change_to(colour)}#{str}\033[0m") if mode == :puts
$stdout.print("#{change_to(colour)}#{str}\033[0m") if mode == :print
end
end
end
def colour_puts(role, str)
ColourCommandLine.new.out_c(:puts, role, str)
end
def colour_print(role, str)
ColourCommandLine.new.out_c(:print, role, str)
end

39
firmware/asdf/test/unity/auto/colour_reporter.rb Normal file
View File

@ -0,0 +1,39 @@
# ==========================================
# Unity Project - A Test Framework for C
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
# [Released under MIT License. Please refer to license.txt for details]
# ==========================================
require_relative 'colour_prompt'
$colour_output = true
def report(message)
if !$colour_output
$stdout.puts(message)
else
message = message.join('\n') if message.class == Array
message.each_line do |line|
line.chomp!
colour = case line
when /(?:total\s+)?tests:?\s+(\d+)\s+(?:total\s+)?failures:?\s+\d+\s+Ignored:?/i
Regexp.last_match(1).to_i.zero? ? :green : :red
when /PASS/
:green
when /^OK$/
:green
when /(?:FAIL|ERROR)/
:red
when /IGNORE/
:yellow
when /^(?:Creating|Compiling|Linking)/
:white
else
:silver
end
colour_puts(colour, line)
end
end
$stdout.flush
$stderr.flush
end

36
firmware/asdf/test/unity/auto/generate_config.yml Normal file
View File

@ -0,0 +1,36 @@
#this is a sample configuration file for generate_module
#you would use it by calling generate_module with the -ygenerate_config.yml option
#files like this are useful for customizing generate_module to your environment
:generate_module:
:defaults:
#these defaults are used in place of any missing options at the command line
:path_src: ../src/
:path_inc: ../src/
:path_tst: ../test/
:update_svn: true
:includes:
#use [] for no additional includes, otherwise list the includes on separate lines
:src:
- Defs.h
- Board.h
:inc: []
:tst:
- Defs.h
- Board.h
- Exception.h
:boilerplates:
#these are inserted at the top of generated files.
#just comment out or remove if not desired.
#use %1$s where you would like the file name to appear (path/extension not included)
:src: |
//-------------------------------------------
// %1$s.c
//-------------------------------------------
:inc: |
//-------------------------------------------
// %1$s.h
//-------------------------------------------
:tst: |
//-------------------------------------------
// Test%1$s.c : Units tests for %1$s.c
//-------------------------------------------

306
firmware/asdf/test/unity/auto/generate_module.rb Normal file
View File

@ -0,0 +1,306 @@
# ==========================================
# Unity Project - A Test Framework for C
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
# [Released under MIT License. Please refer to license.txt for details]
# ==========================================
# This script creates all the files with start code necessary for a new module.
# A simple module only requires a source file, header file, and test file.
# Triad modules require a source, header, and test file for each triad type (like model, conductor, and hardware).
require 'rubygems'
require 'fileutils'
require 'pathname'
# TEMPLATE_TST
TEMPLATE_TST ||= '#include "unity.h"
%2$s#include "%1$s.h"
void setUp(void)
{
}
void tearDown(void)
{
}
void test_%1$s_NeedToImplement(void)
{
TEST_IGNORE_MESSAGE("Need to Implement %1$s");
}
'.freeze
# TEMPLATE_SRC
TEMPLATE_SRC ||= '%2$s#include "%1$s.h"
'.freeze
# TEMPLATE_INC
TEMPLATE_INC ||= '#ifndef _%3$s_H
#define _%3$s_H
%2$s
#endif // _%3$s_H
'.freeze
class UnityModuleGenerator
############################
def initialize(options = nil)
@options = UnityModuleGenerator.default_options
case options
when NilClass then @options
when String then @options.merge!(UnityModuleGenerator.grab_config(options))
when Hash then @options.merge!(options)
else raise 'If you specify arguments, it should be a filename or a hash of options'
end
# Create default file paths if none were provided
@options[:path_src] = "#{__dir__}/../src/" if @options[:path_src].nil?
@options[:path_inc] = @options[:path_src] if @options[:path_inc].nil?
@options[:path_tst] = "#{__dir__}/../test/" if @options[:path_tst].nil?
@options[:path_src] += '/' unless @options[:path_src][-1] == 47
@options[:path_inc] += '/' unless @options[:path_inc][-1] == 47
@options[:path_tst] += '/' unless @options[:path_tst][-1] == 47
# Built in patterns
@patterns = {
'src' => {
'' => { inc: [] }
},
'test' => {
'' => { inc: [] }
},
'dh' => {
'Driver' => { inc: [create_filename('%1$s', 'Hardware.h')] },
'Hardware' => { inc: [] }
},
'dih' => {
'Driver' => { inc: [create_filename('%1$s', 'Hardware.h'), create_filename('%1$s', 'Interrupt.h')] },
'Interrupt' => { inc: [create_filename('%1$s', 'Hardware.h')] },
'Hardware' => { inc: [] }
},
'mch' => {
'Model' => { inc: [] },
'Conductor' => { inc: [create_filename('%1$s', 'Model.h'), create_filename('%1$s', 'Hardware.h')] },
'Hardware' => { inc: [] }
},
'mvp' => {
'Model' => { inc: [] },
'Presenter' => { inc: [create_filename('%1$s', 'Model.h'), create_filename('%1$s', 'View.h')] },
'View' => { inc: [] }
}
}
end
############################
def self.default_options
{
pattern: 'src',
includes: {
src: [],
inc: [],
tst: []
},
update_svn: false,
boilerplates: {},
test_prefix: 'Test',
mock_prefix: 'Mock'
}
end
############################
def self.grab_config(config_file)
options = default_options
unless config_file.nil? || config_file.empty?
require 'yaml'
yaml_guts = YAML.load_file(config_file)
options.merge!(yaml_guts[:unity] || yaml_guts[:cmock])
raise "No :unity or :cmock section found in #{config_file}" unless options
end
options
end
############################
def files_to_operate_on(module_name, pattern = nil)
# strip any leading path information from the module name and save for later
subfolder = File.dirname(module_name)
module_name = File.basename(module_name)
# create triad definition
prefix = @options[:test_prefix] || 'Test'
triad = [{ ext: '.c', path: @options[:path_src], prefix: '', template: TEMPLATE_SRC, inc: :src, boilerplate: @options[:boilerplates][:src] },
{ ext: '.h', path: @options[:path_inc], prefix: '', template: TEMPLATE_INC, inc: :inc, boilerplate: @options[:boilerplates][:inc] },
{ ext: '.c', path: @options[:path_tst], prefix: prefix, template: TEMPLATE_TST, inc: :tst, boilerplate: @options[:boilerplates][:tst] }]
# prepare the pattern for use
pattern = (pattern || @options[:pattern] || 'src').downcase
patterns = @patterns[pattern]
raise "ERROR: The design pattern '#{pattern}' specified isn't one that I recognize!" if patterns.nil?
# single file patterns (currently just 'test') can reject the other parts of the triad
triad.select! { |v| v[:inc] == :tst } if pattern == 'test'
# Assemble the path/names of the files we need to work with.
files = []
triad.each do |cfg|
patterns.each_pair do |pattern_file, pattern_traits|
submodule_name = create_filename(module_name, pattern_file)
filename = cfg[:prefix] + submodule_name + cfg[:ext]
files << {
path: (Pathname.new("#{cfg[:path]}#{subfolder}") + filename).cleanpath,
name: submodule_name,
template: cfg[:template],
boilerplate: cfg[:boilerplate],
includes: case (cfg[:inc])
when :src then (@options[:includes][:src] || []) | (pattern_traits[:inc].map { |f| format(f, module_name) })
when :inc then (@options[:includes][:inc] || [])
when :tst then (@options[:includes][:tst] || []) | (pattern_traits[:inc].map { |f| format("#{@options[:mock_prefix]}#{f}", module_name) })
end
}
end
end
files
end
############################
def create_filename(part1, part2 = '')
if part2.empty?
case (@options[:naming])
when 'bumpy' then part1
when 'camel' then part1
when 'snake' then part1.downcase
when 'caps' then part1.upcase
else part1
end
else
case (@options[:naming])
when 'bumpy' then part1 + part2
when 'camel' then part1 + part2
when 'snake' then part1.downcase + '_' + part2.downcase
when 'caps' then part1.upcase + '_' + part2.upcase
else part1 + '_' + part2
end
end
end
############################
def generate(module_name, pattern = nil)
files = files_to_operate_on(module_name, pattern)
# Abort if all of the module files already exist
all_files_exist = true
files.each do |file|
all_files_exist = false unless File.exist?(file[:path])
end
raise "ERROR: File #{files[0][:name]} already exists. Exiting." if all_files_exist
# Create Source Modules
files.each_with_index do |file, _i|
# If this file already exists, don't overwrite it.
if File.exist?(file[:path])
puts "File #{file[:path]} already exists!"
next
end
# Create the path first if necessary.
FileUtils.mkdir_p(File.dirname(file[:path]), verbose: false)
File.open(file[:path], 'w') do |f|
f.write("#{file[:boilerplate]}\n" % [file[:name]]) unless file[:boilerplate].nil?
f.write(file[:template] % [file[:name],
file[:includes].map { |ff| "#include \"#{ff}\"\n" }.join,
file[:name].upcase])
end
if @options[:update_svn]
`svn add \"#{file[:path]}\"`
if $!.exitstatus.zero?
puts "File #{file[:path]} created and added to source control"
else
puts "File #{file[:path]} created but FAILED adding to source control!"
end
else
puts "File #{file[:path]} created"
end
end
puts 'Generate Complete'
end
############################
def destroy(module_name, pattern = nil)
files_to_operate_on(module_name, pattern).each do |filespec|
file = filespec[:path]
if File.exist?(file)
if @options[:update_svn]
`svn delete \"#{file}\" --force`
puts "File #{file} deleted and removed from source control"
else
FileUtils.remove(file)
puts "File #{file} deleted"
end
else
puts "File #{file} does not exist so cannot be removed."
end
end
puts 'Destroy Complete'
end
end
############################
# Handle As Command Line If Called That Way
if $0 == __FILE__
destroy = false
options = {}
module_name = nil
# Parse the command line parameters.
ARGV.each do |arg|
case arg
when /^-d/ then destroy = true
when /^-u/ then options[:update_svn] = true
when /^-p\"?(\w+)\"?/ then options[:pattern] = Regexp.last_match(1)
when /^-s\"?(.+)\"?/ then options[:path_src] = Regexp.last_match(1)
when /^-i\"?(.+)\"?/ then options[:path_inc] = Regexp.last_match(1)
when /^-t\"?(.+)\"?/ then options[:path_tst] = Regexp.last_match(1)
when /^-n\"?(.+)\"?/ then options[:naming] = Regexp.last_match(1)
when /^-y\"?(.+)\"?/ then options = UnityModuleGenerator.grab_config(Regexp.last_match(1))
when /^(\w+)/
raise "ERROR: You can't have more than one Module name specified!" unless module_name.nil?
module_name = arg
when /^-(h|-help)/
ARGV = [].freeze
else
raise "ERROR: Unknown option specified '#{arg}'"
end
end
unless ARGV[0]
puts ["\nGENERATE MODULE\n-------- ------",
"\nUsage: ruby generate_module [options] module_name",
" -i\"include\" sets the path to output headers to 'include' (DEFAULT ../src)",
" -s\"../src\" sets the path to output source to '../src' (DEFAULT ../src)",
" -t\"C:/test\" sets the path to output source to 'C:/test' (DEFAULT ../test)",
' -p"MCH" sets the output pattern to MCH.',
' dh - driver hardware.',
' dih - driver interrupt hardware.',
' mch - model conductor hardware.',
' mvp - model view presenter.',
' src - just a source module, header and test. (DEFAULT)',
' test - just a test file.',
' -d destroy module instead of creating it.',
' -n"camel" sets the file naming convention.',
' bumpy - BumpyCaseFilenames.',
' camel - camelCaseFilenames.',
' snake - snake_case_filenames.',
' caps - CAPS_CASE_FILENAMES.',
' -u update subversion too (requires subversion command line)',
' -y"my.yml" selects a different yaml config file for module generation',
''].join("\n")
exit
end
raise 'ERROR: You must have a Module name specified! (use option -h for help)' if module_name.nil?
if destroy
UnityModuleGenerator.new(options).destroy(module_name)
else
UnityModuleGenerator.new(options).generate(module_name)
end
end

471
firmware/asdf/test/unity/auto/generate_test_runner.rb Normal file
View File

@ -0,0 +1,471 @@
# ==========================================
# Unity Project - A Test Framework for C
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
# [Released under MIT License. Please refer to license.txt for details]
# ==========================================
class UnityTestRunnerGenerator
def initialize(options = nil)
@options = UnityTestRunnerGenerator.default_options
case options
when NilClass then @options
when String then @options.merge!(UnityTestRunnerGenerator.grab_config(options))
when Hash then @options.merge!(options)
else raise 'If you specify arguments, it should be a filename or a hash of options'
end
require_relative 'type_sanitizer'
end
def self.default_options
{
includes: [],
defines: [],
plugins: [],
framework: :unity,
test_prefix: 'test|spec|should',
mock_prefix: 'Mock',
mock_suffix: '',
setup_name: 'setUp',
teardown_name: 'tearDown',
main_name: 'main', # set to :auto to automatically generate each time
main_export_decl: '',
cmdline_args: false,
use_param_tests: false
}
end
def self.grab_config(config_file)
options = default_options
unless config_file.nil? || config_file.empty?
require 'yaml'
yaml_guts = YAML.load_file(config_file)
options.merge!(yaml_guts[:unity] || yaml_guts[:cmock])
raise "No :unity or :cmock section found in #{config_file}" unless options
end
options
end
def run(input_file, output_file, options = nil)
@options.merge!(options) unless options.nil?
# pull required data from source file
source = File.read(input_file)
source = source.force_encoding('ISO-8859-1').encode('utf-8', replace: nil)
tests = find_tests(source)
headers = find_includes(source)
testfile_includes = (headers[:local] + headers[:system])
used_mocks = find_mocks(testfile_includes)
testfile_includes = (testfile_includes - used_mocks)
testfile_includes.delete_if { |inc| inc =~ /(unity|cmock)/ }
# build runner file
generate(input_file, output_file, tests, used_mocks, testfile_includes)
# determine which files were used to return them
all_files_used = [input_file, output_file]
all_files_used += testfile_includes.map { |filename| filename + '.c' } unless testfile_includes.empty?
all_files_used += @options[:includes] unless @options[:includes].empty?
all_files_used += headers[:linkonly] unless headers[:linkonly].empty?
all_files_used.uniq
end
def generate(input_file, output_file, tests, used_mocks, testfile_includes)
File.open(output_file, 'w') do |output|
create_header(output, used_mocks, testfile_includes)
create_externs(output, tests, used_mocks)
create_mock_management(output, used_mocks)
create_suite_setup(output)
create_suite_teardown(output)
create_reset(output, used_mocks)
create_main(output, input_file, tests, used_mocks)
end
return unless @options[:header_file] && !@options[:header_file].empty?
File.open(@options[:header_file], 'w') do |output|
create_h_file(output, @options[:header_file], tests, testfile_includes, used_mocks)
end
end
def find_tests(source)
tests_and_line_numbers = []
# contains characters which will be substituted from within strings, doing
# this prevents these characters from interferring with scrubbers
# @ is not a valid C character, so there should be no clashes with files genuinely containing these markers
substring_subs = { '{' => '@co@', '}' => '@cc@', ';' => '@ss@', '/' => '@fs@' }
substring_re = Regexp.union(substring_subs.keys)
substring_unsubs = substring_subs.invert # the inverse map will be used to fix the strings afterwords
substring_unsubs['@quote@'] = '\\"'
substring_unsubs['@apos@'] = '\\\''
substring_unre = Regexp.union(substring_unsubs.keys)
source_scrubbed = source.clone
source_scrubbed = source_scrubbed.gsub(/\\"/, '@quote@') # hide escaped quotes to allow capture of the full string/char
source_scrubbed = source_scrubbed.gsub(/\\'/, '@apos@') # hide escaped apostrophes to allow capture of the full string/char
source_scrubbed = source_scrubbed.gsub(/("[^"\n]*")|('[^'\n]*')/) { |s| s.gsub(substring_re, substring_subs) } # temporarily hide problematic
# characters within strings
source_scrubbed = source_scrubbed.gsub(/\/\/.*$/, '') # remove line comments
source_scrubbed = source_scrubbed.gsub(/\/\*.*?\*\//m, '') # remove block comments
lines = source_scrubbed.split(/(^\s*\#.*$) # Treat preprocessor directives as a logical line
| (;|\{|\}) /x) # Match ;, {, and } as end of lines
.map { |line| line.gsub(substring_unre, substring_unsubs) } # unhide the problematic characters previously removed
lines.each_with_index do |line, _index|
# find tests
next unless line =~ /^((?:\s*TEST_CASE\s*\(.*?\)\s*)*)\s*void\s+((?:#{@options[:test_prefix]}).*)\s*\(\s*(.*)\s*\)/
arguments = Regexp.last_match(1)
name = Regexp.last_match(2)
call = Regexp.last_match(3)
params = Regexp.last_match(4)
args = nil
if @options[:use_param_tests] && !arguments.empty?
args = []
arguments.scan(/\s*TEST_CASE\s*\((.*)\)\s*$/) { |a| args << a[0] }
end
tests_and_line_numbers << { test: name, args: args, call: call, params: params, line_number: 0 }
end
tests_and_line_numbers.uniq! { |v| v[:test] }
# determine line numbers and create tests to run
source_lines = source.split("\n")
source_index = 0
tests_and_line_numbers.size.times do |i|
source_lines[source_index..-1].each_with_index do |line, index|
next unless line =~ /\s+#{tests_and_line_numbers[i][:test]}(?:\s|\()/
source_index += index
tests_and_line_numbers[i][:line_number] = source_index + 1
break
end
end
tests_and_line_numbers
end
def find_includes(source)
# remove comments (block and line, in three steps to ensure correct precedence)
source.gsub!(/\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '') # remove line comments that comment out the start of blocks
source.gsub!(/\/\*.*?\*\//m, '') # remove block comments
source.gsub!(/\/\/.*$/, '') # remove line comments (all that remain)
# parse out includes
includes = {
local: source.scan(/^\s*#include\s+\"\s*(.+)\.[hH]\s*\"/).flatten,
system: source.scan(/^\s*#include\s+<\s*(.+)\s*>/).flatten.map { |inc| "<#{inc}>" },
linkonly: source.scan(/^TEST_FILE\(\s*\"\s*(.+)\.[cC]\w*\s*\"/).flatten
}
includes
end
def find_mocks(includes)
mock_headers = []
includes.each do |include_path|
include_file = File.basename(include_path)
mock_headers << include_path if include_file =~ /^#{@options[:mock_prefix]}.*#{@options[:mock_suffix]}$/i
end
mock_headers
end
def create_header(output, mocks, testfile_includes = [])
output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */')
create_runtest(output, mocks)
output.puts("\n/*=======Automagically Detected Files To Include=====*/")
output.puts('#ifdef __WIN32__')
output.puts('#define UNITY_INCLUDE_SETUP_STUBS')
output.puts('#endif')
output.puts("#include \"#{@options[:framework]}.h\"")
output.puts('#include "cmock.h"') unless mocks.empty?
output.puts('#ifndef UNITY_EXCLUDE_SETJMP_H')
output.puts('#include <setjmp.h>')
output.puts('#endif')
output.puts('#include <stdio.h>')
if @options[:defines] && !@options[:defines].empty?
@options[:defines].each { |d| output.puts("#ifndef #{d}\n#define #{d}\n#endif /* #{d} */") }
end
if @options[:header_file] && !@options[:header_file].empty?
output.puts("#include \"#{File.basename(@options[:header_file])}\"")
else
@options[:includes].flatten.uniq.compact.each do |inc|
output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}")
end
testfile_includes.each do |inc|
output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}")
end
end
mocks.each do |mock|
output.puts("#include \"#{mock.gsub('.h', '')}.h\"")
end
output.puts('#include "CException.h"') if @options[:plugins].include?(:cexception)
return unless @options[:enforce_strict_ordering]
output.puts('')
output.puts('int GlobalExpectCount;')
output.puts('int GlobalVerifyOrder;')
output.puts('char* GlobalOrderError;')
end
def create_externs(output, tests, _mocks)
output.puts("\n/*=======External Functions This Runner Calls=====*/")
output.puts("extern void #{@options[:setup_name]}(void);")
output.puts("extern void #{@options[:teardown_name]}(void);")
output.puts("\n#ifdef __cplusplus\nextern \"C\"\n{\n#endif") if @options[:externc]
tests.each do |test|
output.puts("extern void #{test[:test]}(#{test[:call] || 'void'});")
end
output.puts("#ifdef __cplusplus\n}\n#endif") if @options[:externc]
output.puts('')
end
def create_mock_management(output, mock_headers)
return if mock_headers.empty?
output.puts("\n/*=======Mock Management=====*/")
output.puts('static void CMock_Init(void)')
output.puts('{')
if @options[:enforce_strict_ordering]
output.puts(' GlobalExpectCount = 0;')
output.puts(' GlobalVerifyOrder = 0;')
output.puts(' GlobalOrderError = NULL;')
end
mocks = mock_headers.map { |mock| File.basename(mock) }
mocks.each do |mock|
mock_clean = TypeSanitizer.sanitize_c_identifier(mock)
output.puts(" #{mock_clean}_Init();")
end
output.puts("}\n")
output.puts('static void CMock_Verify(void)')
output.puts('{')
mocks.each do |mock|
mock_clean = TypeSanitizer.sanitize_c_identifier(mock)
output.puts(" #{mock_clean}_Verify();")
end
output.puts("}\n")
output.puts('static void CMock_Destroy(void)')
output.puts('{')
mocks.each do |mock|
mock_clean = TypeSanitizer.sanitize_c_identifier(mock)
output.puts(" #{mock_clean}_Destroy();")
end
output.puts("}\n")
end
def create_suite_setup(output)
output.puts("\n/*=======Suite Setup=====*/")
output.puts('static void suite_setup(void)')
output.puts('{')
if @options[:suite_setup].nil?
# New style, call suiteSetUp() if we can use weak symbols
output.puts('#if defined(UNITY_WEAK_ATTRIBUTE) || defined(UNITY_WEAK_PRAGMA)')
output.puts(' suiteSetUp();')
output.puts('#endif')
else
# Old style, C code embedded in the :suite_setup option
output.puts(@options[:suite_setup])
end
output.puts('}')
end
def create_suite_teardown(output)
output.puts("\n/*=======Suite Teardown=====*/")
output.puts('static int suite_teardown(int num_failures)')
output.puts('{')
if @options[:suite_teardown].nil?
# New style, call suiteTearDown() if we can use weak symbols
output.puts('#if defined(UNITY_WEAK_ATTRIBUTE) || defined(UNITY_WEAK_PRAGMA)')
output.puts(' return suiteTearDown(num_failures);')
output.puts('#else')
output.puts(' return num_failures;')
output.puts('#endif')
else
# Old style, C code embedded in the :suite_teardown option
output.puts(@options[:suite_teardown])
end
output.puts('}')
end
def create_runtest(output, used_mocks)
cexception = @options[:plugins].include? :cexception
va_args1 = @options[:use_param_tests] ? ', ...' : ''
va_args2 = @options[:use_param_tests] ? '__VA_ARGS__' : ''
output.puts("\n/*=======Test Runner Used To Run Each Test Below=====*/")
output.puts('#define RUN_TEST_NO_ARGS') if @options[:use_param_tests]
output.puts("#define RUN_TEST(TestFunc, TestLineNum#{va_args1}) \\")
output.puts('{ \\')
output.puts(" Unity.CurrentTestName = #TestFunc#{va_args2.empty? ? '' : " \"(\" ##{va_args2} \")\""}; \\")
output.puts(' Unity.CurrentTestLineNumber = TestLineNum; \\')
output.puts(' if (UnityTestMatches()) { \\') if @options[:cmdline_args]
output.puts(' Unity.NumberOfTests++; \\')
output.puts(' CMock_Init(); \\') unless used_mocks.empty?
output.puts(' UNITY_CLR_DETAILS(); \\') unless used_mocks.empty?
output.puts(' if (TEST_PROTECT()) \\')
output.puts(' { \\')
output.puts(' CEXCEPTION_T e; \\') if cexception
output.puts(' Try { \\') if cexception
output.puts(" #{@options[:setup_name]}(); \\")
output.puts(" TestFunc(#{va_args2}); \\")
output.puts(' } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \\') if cexception
output.puts(' } \\')
output.puts(' if (TEST_PROTECT()) \\')
output.puts(' { \\')
output.puts(" #{@options[:teardown_name]}(); \\")
output.puts(' CMock_Verify(); \\') unless used_mocks.empty?
output.puts(' } \\')
output.puts(' CMock_Destroy(); \\') unless used_mocks.empty?
output.puts(' UnityConcludeTest(); \\')
output.puts(' } \\') if @options[:cmdline_args]
output.puts("}\n")
end
def create_reset(output, used_mocks)
output.puts("\n/*=======Test Reset Option=====*/")
output.puts('void resetTest(void);')
output.puts('void resetTest(void)')
output.puts('{')
output.puts(' CMock_Verify();') unless used_mocks.empty?
output.puts(' CMock_Destroy();') unless used_mocks.empty?
output.puts(" #{@options[:teardown_name]}();")
output.puts(' CMock_Init();') unless used_mocks.empty?
output.puts(" #{@options[:setup_name]}();")
output.puts('}')
end
def create_main(output, filename, tests, used_mocks)
output.puts("\n\n/*=======MAIN=====*/")
main_name = @options[:main_name].to_sym == :auto ? "main_#{filename.gsub('.c', '')}" : (@options[:main_name]).to_s
if @options[:cmdline_args]
if main_name != 'main'
output.puts("#{@options[:main_export_decl]} int #{main_name}(int argc, char** argv);")
end
output.puts("#{@options[:main_export_decl]} int #{main_name}(int argc, char** argv)")
output.puts('{')
output.puts(' int parse_status = UnityParseOptions(argc, argv);')
output.puts(' if (parse_status != 0)')
output.puts(' {')
output.puts(' if (parse_status < 0)')
output.puts(' {')
output.puts(" UnityPrint(\"#{filename.gsub('.c', '')}.\");")
output.puts(' UNITY_PRINT_EOL();')
if @options[:use_param_tests]
tests.each do |test|
if test[:args].nil? || test[:args].empty?
output.puts(" UnityPrint(\" #{test[:test]}(RUN_TEST_NO_ARGS)\");")
output.puts(' UNITY_PRINT_EOL();')
else
test[:args].each do |args|
output.puts(" UnityPrint(\" #{test[:test]}(#{args})\");")
output.puts(' UNITY_PRINT_EOL();')
end
end
end
else
tests.each { |test| output.puts(" UnityPrint(\" #{test[:test]}\");\n UNITY_PRINT_EOL();") }
end
output.puts(' return 0;')
output.puts(' }')
output.puts(' return parse_status;')
output.puts(' }')
else
if main_name != 'main'
output.puts("#{@options[:main_export_decl]} int #{main_name}(void);")
end
output.puts("int #{main_name}(void)")
output.puts('{')
end
output.puts(' suite_setup();')
output.puts(" UnityBegin(\"#{filename.gsub(/\\/, '\\\\\\')}\");")
if @options[:use_param_tests]
tests.each do |test|
if test[:args].nil? || test[:args].empty?
output.puts(" RUN_TEST(#{test[:test]}, #{test[:line_number]}, RUN_TEST_NO_ARGS);")
else
test[:args].each { |args| output.puts(" RUN_TEST(#{test[:test]}, #{test[:line_number]}, #{args});") }
end
end
else
tests.each { |test| output.puts(" RUN_TEST(#{test[:test]}, #{test[:line_number]});") }
end
output.puts
output.puts(' CMock_Guts_MemFreeFinal();') unless used_mocks.empty?
output.puts(' return suite_teardown(UnityEnd());')
output.puts('}')
end
def create_h_file(output, filename, tests, testfile_includes, used_mocks)
filename = File.basename(filename).gsub(/[-\/\\\.\,\s]/, '_').upcase
output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */')
output.puts("#ifndef _#{filename}")
output.puts("#define _#{filename}\n\n")
output.puts("#include \"#{@options[:framework]}.h\"")
output.puts('#include "cmock.h"') unless used_mocks.empty?
@options[:includes].flatten.uniq.compact.each do |inc|
output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}")
end
testfile_includes.each do |inc|
output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}")
end
output.puts "\n"
tests.each do |test|
if test[:params].nil? || test[:params].empty?
output.puts("void #{test[:test]}(void);")
else
output.puts("void #{test[:test]}(#{test[:params]});")
end
end
output.puts("#endif\n\n")
end
end
if $0 == __FILE__
options = { includes: [] }
# parse out all the options first (these will all be removed as we go)
ARGV.reject! do |arg|
case arg
when '-cexception'
options[:plugins] = [:cexception]
true
when /\.*\.ya?ml/
options = UnityTestRunnerGenerator.grab_config(arg)
true
when /--(\w+)=\"?(.*)\"?/
options[Regexp.last_match(1).to_sym] = Regexp.last_match(2)
true
when /\.*\.h/
options[:includes] << arg
true
else false
end
end
# make sure there is at least one parameter left (the input file)
unless ARGV[0]
puts ["\nusage: ruby #{__FILE__} (files) (options) input_test_file (output)",
"\n input_test_file - this is the C file you want to create a runner for",
' output - this is the name of the runner file to generate',
' defaults to (input_test_file)_Runner',
' files:',
' *.yml / *.yaml - loads configuration from here in :unity or :cmock',
' *.h - header files are added as #includes in runner',
' options:',
' -cexception - include cexception support',
' -externc - add extern "C" for cpp support',
' --setup_name="" - redefine setUp func name to something else',
' --teardown_name="" - redefine tearDown func name to something else',
' --main_name="" - redefine main func name to something else',
' --test_prefix="" - redefine test prefix from default test|spec|should',
' --suite_setup="" - code to execute for setup of entire suite',
' --suite_teardown="" - code to execute for teardown of entire suite',
' --use_param_tests=1 - enable parameterized tests (disabled by default)',
' --header_file="" - path/name of test header file to generate too'].join("\n")
exit 1
end
# create the default test runner name if not specified
ARGV[1] = ARGV[0].gsub('.c', '_Runner.c') unless ARGV[1]
UnityTestRunnerGenerator.new(options).run(ARGV[0], ARGV[1])
end

322
firmware/asdf/test/unity/auto/parse_output.rb Normal file
View File

@ -0,0 +1,322 @@
#============================================================
# Author: John Theofanopoulos
# A simple parser. Takes the output files generated during the
# build process and extracts information relating to the tests.
#
# Notes:
# To capture an output file under VS builds use the following:
# devenv [build instructions] > Output.txt & type Output.txt
#
# To capture an output file under Linux builds use the following:
# make | tee Output.txt
#
# This script can handle the following output formats:
# - normal output (raw unity)
# - fixture output (unity_fixture.h/.c)
# - fixture output with verbose flag set ("-v")
#
# To use this parser use the following command
# ruby parseOutput.rb [options] [file]
# options: -xml : produce a JUnit compatible XML file
# file: file to scan for results
#============================================================
# Parser class for handling the input file
class ParseOutput
def initialize
# internal data
@class_name_idx = 0
@path_delim = nil
# xml output related
@xml_out = false
@array_list = false
# current suite name and statistics
@test_suite = nil
@total_tests = 0
@test_passed = 0
@test_failed = 0
@test_ignored = 0
end
# Set the flag to indicate if there will be an XML output file or not
def set_xml_output
@xml_out = true
end
# If write our output to XML
def write_xml_output
output = File.open('report.xml', 'w')
output << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
@array_list.each do |item|
output << item << "\n"
end
end
# Pushes the suite info as xml to the array list, which will be written later
def push_xml_output_suite_info
# Insert opening tag at front
heading = '<testsuite name="Unity" tests="' + @total_tests.to_s + '" failures="' + @test_failed.to_s + '"' + ' skips="' + @test_ignored.to_s + '">'
@array_list.insert(0, heading)
# Push back the closing tag
@array_list.push '</testsuite>'
end
# Pushes xml output data to the array list, which will be written later
def push_xml_output_passed(test_name)
@array_list.push ' <testcase classname="' + @test_suite + '" name="' + test_name + '"/>'
end
# Pushes xml output data to the array list, which will be written later
def push_xml_output_failed(test_name, reason)
@array_list.push ' <testcase classname="' + @test_suite + '" name="' + test_name + '">'
@array_list.push ' <failure type="ASSERT FAILED">' + reason + '</failure>'
@array_list.push ' </testcase>'
end
# Pushes xml output data to the array list, which will be written later
def push_xml_output_ignored(test_name, reason)
@array_list.push ' <testcase classname="' + @test_suite + '" name="' + test_name + '">'
@array_list.push ' <skipped type="TEST IGNORED">' + reason + '</skipped>'
@array_list.push ' </testcase>'
end
# This function will try and determine when the suite is changed. This is
# is the name that gets added to the classname parameter.
def test_suite_verify(test_suite_name)
# Split the path name
test_name = test_suite_name.split(@path_delim)
# Remove the extension and extract the base_name
base_name = test_name[test_name.size - 1].split('.')[0]
# Return if the test suite hasn't changed
return unless base_name.to_s != @test_suite.to_s
@test_suite = base_name
printf "New Test: %s\n", @test_suite
end
# Prepares the line for verbose fixture output ("-v")
def prepare_fixture_line(line)
line = line.sub('IGNORE_TEST(', '')
line = line.sub('TEST(', '')
line = line.sub(')', ',')
line = line.chomp
array = line.split(',')
array.map { |x| x.to_s.lstrip.chomp }
end
# Test was flagged as having passed so format the output.
# This is using the Unity fixture output and not the original Unity output.
def test_passed_unity_fixture(array)
class_name = array[0]
test_name = array[1]
test_suite_verify(class_name)
printf "%-40s PASS\n", test_name
push_xml_output_passed(test_name) if @xml_out
end
# Test was flagged as having failed so format the output.
# This is using the Unity fixture output and not the original Unity output.
def test_failed_unity_fixture(array)
class_name = array[0]
test_name = array[1]
test_suite_verify(class_name)
reason_array = array[2].split(':')
reason = reason_array[-1].lstrip.chomp + ' at line: ' + reason_array[-4]
printf "%-40s FAILED\n", test_name
push_xml_output_failed(test_name, reason) if @xml_out
end
# Test was flagged as being ignored so format the output.
# This is using the Unity fixture output and not the original Unity output.
def test_ignored_unity_fixture(array)
class_name = array[0]
test_name = array[1]
reason = 'No reason given'
if array.size > 2
reason_array = array[2].split(':')
tmp_reason = reason_array[-1].lstrip.chomp
reason = tmp_reason == 'IGNORE' ? 'No reason given' : tmp_reason
end
test_suite_verify(class_name)
printf "%-40s IGNORED\n", test_name
push_xml_output_ignored(test_name, reason) if @xml_out
end
# Test was flagged as having passed so format the output
def test_passed(array)
last_item = array.length - 1
test_name = array[last_item - 1]
test_suite_verify(array[@class_name_idx])
printf "%-40s PASS\n", test_name
return unless @xml_out
push_xml_output_passed(test_name) if @xml_out
end
# Test was flagged as having failed so format the line
def test_failed(array)
last_item = array.length - 1
test_name = array[last_item - 2]
reason = array[last_item].chomp.lstrip + ' at line: ' + array[last_item - 3]
class_name = array[@class_name_idx]
if test_name.start_with? 'TEST('
array2 = test_name.split(' ')
test_suite = array2[0].sub('TEST(', '')
test_suite = test_suite.sub(',', '')
class_name = test_suite
test_name = array2[1].sub(')', '')
end
test_suite_verify(class_name)
printf "%-40s FAILED\n", test_name
push_xml_output_failed(test_name, reason) if @xml_out
end
# Test was flagged as being ignored so format the output
def test_ignored(array)
last_item = array.length - 1
test_name = array[last_item - 2]
reason = array[last_item].chomp.lstrip
class_name = array[@class_name_idx]
if test_name.start_with? 'TEST('
array2 = test_name.split(' ')
test_suite = array2[0].sub('TEST(', '')
test_suite = test_suite.sub(',', '')
class_name = test_suite
test_name = array2[1].sub(')', '')
end
test_suite_verify(class_name)
printf "%-40s IGNORED\n", test_name
push_xml_output_ignored(test_name, reason) if @xml_out
end
# Adjusts the os specific members according to the current path style
# (Windows or Unix based)
def detect_os_specifics(line)
if line.include? '\\'
# Windows X:\Y\Z
@class_name_idx = 1
@path_delim = '\\'
else
# Unix Based /X/Y/Z
@class_name_idx = 0
@path_delim = '/'
end
end
# Main function used to parse the file that was captured.
def process(file_name)
@array_list = []
puts 'Parsing file: ' + file_name
@test_passed = 0
@test_failed = 0
@test_ignored = 0
puts ''
puts '=================== RESULTS ====================='
puts ''
File.open(file_name).each do |line|
# Typical test lines look like these:
# ----------------------------------------------------
# 1. normal output:
# <path>/<test_file>.c:36:test_tc1000_opsys:FAIL: Expected 1 Was 0
# <path>/<test_file>.c:112:test_tc5004_initCanChannel:IGNORE: Not Yet Implemented
# <path>/<test_file>.c:115:test_tc5100_initCanVoidPtrs:PASS
#
# 2. fixture output
# <path>/<test_file>.c:63:TEST(<test_group>, <test_function>):FAIL: Expected 0x00001234 Was 0x00005A5A
# <path>/<test_file>.c:36:TEST(<test_group>, <test_function>):IGNORE
# Note: "PASS" information won't be generated in this mode
#
# 3. fixture output with verbose information ("-v")
# TEST(<test_group, <test_file>)<path>/<test_file>:168::FAIL: Expected 0x8D Was 0x8C
# TEST(<test_group>, <test_file>)<path>/<test_file>:22::IGNORE: This Test Was Ignored On Purpose
# IGNORE_TEST(<test_group, <test_file>)
# TEST(<test_group, <test_file>) PASS
#
# Note: Where path is different on Unix vs Windows devices (Windows leads with a drive letter)!
detect_os_specifics(line)
line_array = line.split(':')
# If we were able to split the line then we can look to see if any of our target words
# were found. Case is important.
next unless (line_array.size >= 4) || (line.start_with? 'TEST(') || (line.start_with? 'IGNORE_TEST(')
# check if the output is fixture output (with verbose flag "-v")
if (line.start_with? 'TEST(') || (line.start_with? 'IGNORE_TEST(')
line_array = prepare_fixture_line(line)
if line.include? ' PASS'
test_passed_unity_fixture(line_array)
@test_passed += 1
elsif line.include? 'FAIL'
test_failed_unity_fixture(line_array)
@test_failed += 1
elsif line.include? 'IGNORE'
test_ignored_unity_fixture(line_array)
@test_ignored += 1
end
# normal output / fixture output (without verbose "-v")
elsif line.include? ':PASS'
test_passed(line_array)
@test_passed += 1
elsif line.include? ':FAIL'
test_failed(line_array)
@test_failed += 1
elsif line.include? ':IGNORE:'
test_ignored(line_array)
@test_ignored += 1
elsif line.include? ':IGNORE'
line_array.push('No reason given')
test_ignored(line_array)
@test_ignored += 1
end
@total_tests = @test_passed + @test_failed + @test_ignored
end
puts ''
puts '=================== SUMMARY ====================='
puts ''
puts 'Tests Passed : ' + @test_passed.to_s
puts 'Tests Failed : ' + @test_failed.to_s
puts 'Tests Ignored : ' + @test_ignored.to_s
return unless @xml_out
# push information about the suite
push_xml_output_suite_info
# write xml output file
write_xml_output
end
end
# If the command line has no values in, used a default value of Output.txt
parse_my_file = ParseOutput.new
if ARGV.size >= 1
ARGV.each do |arg|
if arg == '-xml'
parse_my_file.set_xml_output
else
parse_my_file.process(arg)
break
end
end
end

248
firmware/asdf/test/unity/auto/stylize_as_junit.rb Executable file
View File

@ -0,0 +1,248 @@
#!/usr/bin/ruby
#
# unity_to_junit.rb
#
require 'fileutils'
require 'optparse'
require 'ostruct'
require 'set'
require 'pp'
VERSION = 1.0
class ArgvParser
#
# Return a structure describing the options.
#
def self.parse(args)
# The options specified on the command line will be collected in *options*.
# We set default values here.
options = OpenStruct.new
options.results_dir = '.'
options.root_path = '.'
options.out_file = 'results.xml'
opts = OptionParser.new do |o|
o.banner = 'Usage: unity_to_junit.rb [options]'
o.separator ''
o.separator 'Specific options:'
o.on('-r', '--results <dir>', 'Look for Unity Results files here.') do |results|
# puts "results #{results}"
options.results_dir = results
end
o.on('-p', '--root_path <path>', 'Prepend this path to files in results.') do |root_path|
options.root_path = root_path
end
o.on('-o', '--output <filename>', 'XML file to generate.') do |out_file|
# puts "out_file: #{out_file}"
options.out_file = out_file
end
o.separator ''
o.separator 'Common options:'
# No argument, shows at tail. This will print an options summary.
o.on_tail('-h', '--help', 'Show this message') do
puts o
exit
end
# Another typical switch to print the version.
o.on_tail('--version', 'Show version') do
puts "unity_to_junit.rb version #{VERSION}"
exit
end
end
opts.parse!(args)
options
end
end
class UnityToJUnit
include FileUtils::Verbose
attr_reader :report, :total_tests, :failures, :ignored
attr_writer :targets, :root, :out_file
def initialize
@report = ''
@unit_name = ''
end
def run
# Clean up result file names
results = @targets.map { |target| target.tr('\\', '/') }
# puts "Output File: #{@out_file}"
f = File.new(@out_file, 'w')
write_xml_header(f)
write_suites_header(f)
results.each do |result_file|
lines = File.readlines(result_file).map(&:chomp)
raise "Empty test result file: #{result_file}" if lines.empty?
result_output = get_details(result_file, lines)
tests, failures, ignored = parse_test_summary(lines)
result_output[:counts][:total] = tests
result_output[:counts][:failed] = failures
result_output[:counts][:ignored] = ignored
result_output[:counts][:passed] = (result_output[:counts][:total] - result_output[:counts][:failed] - result_output[:counts][:ignored])
# use line[0] from the test output to get the test_file path and name
test_file_str = lines[0].tr('\\', '/')
test_file_str = test_file_str.split(':')
test_file = if test_file_str.length < 2
result_file
else
test_file_str[0] + ':' + test_file_str[1]
end
result_output[:source][:path] = File.dirname(test_file)
result_output[:source][:file] = File.basename(test_file)
# save result_output
@unit_name = File.basename(test_file, '.*')
write_suite_header(result_output[:counts], f)
write_failures(result_output, f)
write_tests(result_output, f)
write_ignored(result_output, f)
write_suite_footer(f)
end
write_suites_footer(f)
f.close
end
def usage(err_msg = nil)
puts "\nERROR: "
puts err_msg if err_msg
puts 'Usage: unity_to_junit.rb [options]'
puts ''
puts 'Specific options:'
puts ' -r, --results <dir> Look for Unity Results files here.'
puts ' -p, --root_path <path> Prepend this path to files in results.'
puts ' -o, --output <filename> XML file to generate.'
puts ''
puts 'Common options:'
puts ' -h, --help Show this message'
puts ' --version Show version'
exit 1
end
protected
def get_details(_result_file, lines)
results = results_structure
lines.each do |line|
line = line.tr('\\', '/')
_src_file, src_line, test_name, status, msg = line.split(/:/)
case status
when 'IGNORE' then results[:ignores] << { test: test_name, line: src_line, message: msg }
when 'FAIL' then results[:failures] << { test: test_name, line: src_line, message: msg }
when 'PASS' then results[:successes] << { test: test_name, line: src_line, message: msg }
end
end
results
end
def parse_test_summary(summary)
raise "Couldn't parse test results: #{summary}" unless summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ }
[Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i]
end
private
def results_structure
{
source: { path: '', file: '' },
successes: [],
failures: [],
ignores: [],
counts: { total: 0, passed: 0, failed: 0, ignored: 0 },
stdout: []
}
end
def write_xml_header(stream)
stream.puts "<?xml version='1.0' encoding='utf-8' ?>"
end
def write_suites_header(stream)
stream.puts '<testsuites>'
end
def write_suite_header(counts, stream)
stream.puts "\t<testsuite errors=\"0\" skipped=\"#{counts[:ignored]}\" failures=\"#{counts[:failed]}\" tests=\"#{counts[:total]}\" name=\"unity\">"
end
def write_failures(results, stream)
result = results[:failures]
result.each do |item|
filename = File.join(results[:source][:path], File.basename(results[:source][:file], '.*'))
stream.puts "\t\t<testcase classname=\"#{@unit_name}\" name=\"#{item[:test]}\" time=\"0\">"
stream.puts "\t\t\t<failure message=\"#{item[:message]}\" type=\"Assertion\"/>"
stream.puts "\t\t\t<system-err>&#xD;[File] #{filename}&#xD;[Line] #{item[:line]}&#xD;</system-err>"
stream.puts "\t\t</testcase>"
end
end
def write_tests(results, stream)
result = results[:successes]
result.each do |item|
stream.puts "\t\t<testcase classname=\"#{@unit_name}\" name=\"#{item[:test]}\" time=\"0\" />"
end
end
def write_ignored(results, stream)
result = results[:ignores]
result.each do |item|
filename = File.join(results[:source][:path], File.basename(results[:source][:file], '.*'))
puts "Writing ignored tests for test harness: #{filename}"
stream.puts "\t\t<testcase classname=\"#{@unit_name}\" name=\"#{item[:test]}\" time=\"0\">"
stream.puts "\t\t\t<skipped message=\"#{item[:message]}\" type=\"Assertion\"/>"
stream.puts "\t\t\t<system-err>&#xD;[File] #{filename}&#xD;[Line] #{item[:line]}&#xD;</system-err>"
stream.puts "\t\t</testcase>"
end
end
def write_suite_footer(stream)
stream.puts "\t</testsuite>"
end
def write_suites_footer(stream)
stream.puts '</testsuites>'
end
end
if $0 == __FILE__
# parse out the command options
options = ArgvParser.parse(ARGV)
# create an instance to work with
utj = UnityToJUnit.new
begin
# look in the specified or current directory for result files
targets = "#{options.results_dir.tr('\\', '/')}**/*.test*"
results = Dir[targets]
raise "No *.testpass, *.testfail, or *.testresults files found in '#{targets}'" if results.empty?
utj.targets = results
# set the root path
utj.root = options.root_path
# set the output XML file name
# puts "Output File from options: #{options.out_file}"
utj.out_file = options.out_file
# run the summarizer
puts utj.run
rescue StandardError => e
utj.usage e.message
end
end

25
firmware/asdf/test/unity/auto/test_file_filter.rb Normal file
View File

@ -0,0 +1,25 @@
# ==========================================
# Unity Project - A Test Framework for C
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
# [Released under MIT License. Please refer to license.txt for details]
# ==========================================
require'yaml'
module RakefileHelpers
class TestFileFilter
def initialize(all_files = false)
@all_files = all_files
return unless @all_files
return unless File.exist?('test_file_filter.yml')
filters = YAML.load_file('test_file_filter.yml')
@all_files = filters[:all_files]
@only_files = filters[:only_files]
@exclude_files = filters[:exclude_files]
end
attr_accessor :all_files, :only_files, :exclude_files
end
end

6
firmware/asdf/test/unity/auto/type_sanitizer.rb Normal file
View File

@ -0,0 +1,6 @@
module TypeSanitizer
def self.sanitize_c_identifier(unsanitized)
# convert filename to valid C identifier by replacing invalid chars with '_'
unsanitized.gsub(/[-\/\\\.\,\s]/, '_')
end
end

139
firmware/asdf/test/unity/auto/unity_test_summary.py Normal file
View File

@ -0,0 +1,139 @@
#! python3
# ==========================================
# Unity Project - A Test Framework for C
# Copyright (c) 2015 Alexander Mueller / XelaRellum@web.de
# [Released under MIT License. Please refer to license.txt for details]
# Based on the ruby script by Mike Karlesky, Mark VanderVoord, Greg Williams
# ==========================================
import sys
import os
import re
from glob import glob
class UnityTestSummary:
def __init__(self):
self.report = ''
self.total_tests = 0
self.failures = 0
self.ignored = 0
def run(self):
# Clean up result file names
results = []
for target in self.targets:
results.append(target.replace('\\', '/'))
# Dig through each result file, looking for details on pass/fail:
failure_output = []
ignore_output = []
for result_file in results:
lines = list(map(lambda line: line.rstrip(), open(result_file, "r").read().split('\n')))
if len(lines) == 0:
raise Exception("Empty test result file: %s" % result_file)
details = self.get_details(result_file, lines)
failures = details['failures']
ignores = details['ignores']
if len(failures) > 0: failure_output.append('\n'.join(failures))
if len(ignores) > 0: ignore_output.append('n'.join(ignores))
tests,failures,ignored = self.parse_test_summary('\n'.join(lines))
self.total_tests += tests
self.failures += failures
self.ignored += ignored
if self.ignored > 0:
self.report += "\n"
self.report += "--------------------------\n"
self.report += "UNITY IGNORED TEST SUMMARY\n"
self.report += "--------------------------\n"
self.report += "\n".join(ignore_output)
if self.failures > 0:
self.report += "\n"
self.report += "--------------------------\n"
self.report += "UNITY FAILED TEST SUMMARY\n"
self.report += "--------------------------\n"
self.report += '\n'.join(failure_output)
self.report += "\n"
self.report += "--------------------------\n"
self.report += "OVERALL UNITY TEST SUMMARY\n"
self.report += "--------------------------\n"
self.report += "{total_tests} TOTAL TESTS {failures} TOTAL FAILURES {ignored} IGNORED\n".format(total_tests = self.total_tests, failures=self.failures, ignored=self.ignored)
self.report += "\n"
return self.report
def set_targets(self, target_array):
self.targets = target_array
def set_root_path(self, path):
self.root = path
def usage(self, err_msg=None):
print("\nERROR: ")
if err_msg:
print(err_msg)
print("\nUsage: unity_test_summary.py result_file_directory/ root_path/")
print(" result_file_directory - The location of your results files.")
print(" Defaults to current directory if not specified.")
print(" Should end in / if specified.")
print(" root_path - Helpful for producing more verbose output if using relative paths.")
sys.exit(1)
def get_details(self, result_file, lines):
results = { 'failures': [], 'ignores': [], 'successes': [] }
for line in lines:
parts = line.split(':')
if len(parts) == 5:
src_file,src_line,test_name,status,msg = parts
elif len(parts) == 4:
src_file,src_line,test_name,status = parts
msg = ''
else:
continue
if len(self.root) > 0:
line_out = "%s%s" % (self.root, line)
else:
line_out = line
if status == 'IGNORE':
results['ignores'].append(line_out)
elif status == 'FAIL':
results['failures'].append(line_out)
elif status == 'PASS':
results['successes'].append(line_out)
return results
def parse_test_summary(self, summary):
m = re.search(r"([0-9]+) Tests ([0-9]+) Failures ([0-9]+) Ignored", summary)
if not m:
raise Exception("Couldn't parse test results: %s" % summary)
return int(m.group(1)), int(m.group(2)), int(m.group(3))
if __name__ == '__main__':
uts = UnityTestSummary()
try:
#look in the specified or current directory for result files
if len(sys.argv) > 1:
targets_dir = sys.argv[1]
else:
targets_dir = './'
targets = list(map(lambda x: x.replace('\\', '/'), glob(targets_dir + '*.test*')))
if len(targets) == 0:
raise Exception("No *.testpass or *.testfail files found in '%s'" % targets_dir)
uts.set_targets(targets)
#set the root path
if len(sys.argv) > 2:
root_path = sys.argv[2]
else:
root_path = os.path.split(__file__)[0]
uts.set_root_path(root_path)
#run the summarizer
print(uts.run())
except Exception as e:
uts.usage(e)

132
firmware/asdf/test/unity/auto/unity_test_summary.rb Normal file
View File

@ -0,0 +1,132 @@
# ==========================================
# Unity Project - A Test Framework for C
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
# [Released under MIT License. Please refer to license.txt for details]
# ==========================================
# !/usr/bin/ruby
#
# unity_test_summary.rb
#
require 'fileutils'
require 'set'
class UnityTestSummary
include FileUtils::Verbose
attr_reader :report, :total_tests, :failures, :ignored
attr_writer :targets, :root
def initialize(_opts = {})
@report = ''
@total_tests = 0
@failures = 0
@ignored = 0
end
def run
# Clean up result file names
results = @targets.map { |target| target.tr('\\', '/') }
# Dig through each result file, looking for details on pass/fail:
failure_output = []
ignore_output = []
results.each do |result_file|
lines = File.readlines(result_file).map(&:chomp)
raise "Empty test result file: #{result_file}" if lines.empty?
output = get_details(result_file, lines)
failure_output << output[:failures] unless output[:failures].empty?
ignore_output << output[:ignores] unless output[:ignores].empty?
tests, failures, ignored = parse_test_summary(lines)
@total_tests += tests
@failures += failures
@ignored += ignored
end
if @ignored > 0
@report += "\n"
@report += "--------------------------\n"
@report += "UNITY IGNORED TEST SUMMARY\n"
@report += "--------------------------\n"
@report += ignore_output.flatten.join("\n")
end
if @failures > 0
@report += "\n"
@report += "--------------------------\n"
@report += "UNITY FAILED TEST SUMMARY\n"
@report += "--------------------------\n"
@report += failure_output.flatten.join("\n")
end
@report += "\n"
@report += "--------------------------\n"
@report += "OVERALL UNITY TEST SUMMARY\n"
@report += "--------------------------\n"
@report += "#{@total_tests} TOTAL TESTS #{@failures} TOTAL FAILURES #{@ignored} IGNORED\n"
@report += "\n"
end
def usage(err_msg = nil)
puts "\nERROR: "
puts err_msg if err_msg
puts "\nUsage: unity_test_summary.rb result_file_directory/ root_path/"
puts ' result_file_directory - The location of your results files.'
puts ' Defaults to current directory if not specified.'
puts ' Should end in / if specified.'
puts ' root_path - Helpful for producing more verbose output if using relative paths.'
exit 1
end
protected
def get_details(_result_file, lines)
results = { failures: [], ignores: [], successes: [] }
lines.each do |line|
_src_file, _src_line, _test_name, status, _msg = line.split(/:/)
line_out = (@root && (@root != 0) ? "#{@root}#{line}" : line).gsub(/\//, '\\')
case status
when 'IGNORE' then results[:ignores] << line_out
when 'FAIL' then results[:failures] << line_out
when 'PASS' then results[:successes] << line_out
end
end
results
end
def parse_test_summary(summary)
raise "Couldn't parse test results: #{summary}" unless summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ }
[Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i]
end
end
if $0 == __FILE__
# parse out the command options
opts, args = ARGV.partition { |v| v =~ /^--\w+/ }
opts.map! { |v| v[2..-1].to_sym }
# create an instance to work with
uts = UnityTestSummary.new(opts)
begin
# look in the specified or current directory for result files
args[0] ||= './'
targets = "#{ARGV[0].tr('\\', '/')}**/*.test*"
results = Dir[targets]
raise "No *.testpass, *.testfail, or *.testresults files found in '#{targets}'" if results.empty?
uts.targets = results
# set the root path
args[1] ||= Dir.pwd + '/'
uts.root = ARGV[1]
# run the summarizer
puts uts.run
rescue StandardError => e
uts.usage e.message
end
end

146
firmware/asdf/test/unity/auto/unity_to_junit.py Normal file
View File

@ -0,0 +1,146 @@
import sys
import os
from glob import glob
from pyparsing import *
from junit_xml import TestSuite, TestCase
class UnityTestSummary:
def __init__(self):
self.report = ''
self.total_tests = 0
self.failures = 0
self.ignored = 0
self.targets = 0
self.root = None
self.test_suites = dict()
def run(self):
# Clean up result file names
results = []
for target in self.targets:
results.append(target.replace('\\', '/'))
# Dig through each result file, looking for details on pass/fail:
for result_file in results:
lines = list(map(lambda line: line.rstrip(), open(result_file, "r").read().split('\n')))
if len(lines) == 0:
raise Exception("Empty test result file: %s" % result_file)
# define an expression for your file reference
entry_one = Combine(
oneOf(list(alphas)) + ':/' +
Word(alphanums + '_-./'))
entry_two = Word(printables + ' ', excludeChars=':')
entry = entry_one | entry_two
delimiter = Literal(':').suppress()
tc_result_line = Group(entry.setResultsName('tc_file_name') + delimiter + entry.setResultsName(
'tc_line_nr') + delimiter + entry.setResultsName('tc_name') + delimiter + entry.setResultsName(
'tc_status') + Optional(
delimiter + entry.setResultsName('tc_msg'))).setResultsName("tc_line")
eol = LineEnd().suppress()
sol = LineStart().suppress()
blank_line = sol + eol
tc_summary_line = Group(Word(nums).setResultsName("num_of_tests") + "Tests" + Word(nums).setResultsName(
"num_of_fail") + "Failures" + Word(nums).setResultsName("num_of_ignore") + "Ignored").setResultsName(
"tc_summary")
tc_end_line = Or(Literal("FAIL"), Literal('Ok')).setResultsName("tc_result")
# run it and see...
pp1 = tc_result_line | Optional(tc_summary_line | tc_end_line)
pp1.ignore(blank_line | OneOrMore("-"))
result = list()
for l in lines:
result.append((pp1.parseString(l)).asDict())
# delete empty results
result = filter(None, result)
tc_list = list()
for r in result:
if 'tc_line' in r:
tmp_tc_line = r['tc_line']
# get only the file name which will be used as the classname
file_name = tmp_tc_line['tc_file_name'].split('\\').pop().split('/').pop().rsplit('.', 1)[0]
tmp_tc = TestCase(name=tmp_tc_line['tc_name'], classname=file_name)
if 'tc_status' in tmp_tc_line:
if str(tmp_tc_line['tc_status']) == 'IGNORE':
if 'tc_msg' in tmp_tc_line:
tmp_tc.add_skipped_info(message=tmp_tc_line['tc_msg'],
output=r'[File]={0}, [Line]={1}'.format(
tmp_tc_line['tc_file_name'], tmp_tc_line['tc_line_nr']))
else:
tmp_tc.add_skipped_info(message=" ")
elif str(tmp_tc_line['tc_status']) == 'FAIL':
if 'tc_msg' in tmp_tc_line:
tmp_tc.add_failure_info(message=tmp_tc_line['tc_msg'],
output=r'[File]={0}, [Line]={1}'.format(
tmp_tc_line['tc_file_name'], tmp_tc_line['tc_line_nr']))
else:
tmp_tc.add_failure_info(message=" ")
tc_list.append((str(result_file), tmp_tc))
for k, v in tc_list:
try:
self.test_suites[k].append(v)
except KeyError:
self.test_suites[k] = [v]
ts = []
for suite_name in self.test_suites:
ts.append(TestSuite(suite_name, self.test_suites[suite_name]))
with open('result.xml', 'w') as f:
TestSuite.to_file(f, ts, prettyprint='True', encoding='utf-8')
return self.report
def set_targets(self, target_array):
self.targets = target_array
def set_root_path(self, path):
self.root = path
@staticmethod
def usage(err_msg=None):
print("\nERROR: ")
if err_msg:
print(err_msg)
print("\nUsage: unity_test_summary.py result_file_directory/ root_path/")
print(" result_file_directory - The location of your results files.")
print(" Defaults to current directory if not specified.")
print(" Should end in / if specified.")
print(" root_path - Helpful for producing more verbose output if using relative paths.")
sys.exit(1)
if __name__ == '__main__':
uts = UnityTestSummary()
try:
# look in the specified or current directory for result files
if len(sys.argv) > 1:
targets_dir = sys.argv[1]
else:
targets_dir = './'
targets = list(map(lambda x: x.replace('\\', '/'), glob(targets_dir + '*.test*')))
if len(targets) == 0:
raise Exception("No *.testpass or *.testfail files found in '%s'" % targets_dir)
uts.set_targets(targets)
# set the root path
if len(sys.argv) > 2:
root_path = sys.argv[2]
else:
root_path = os.path.split(__file__)[0]
uts.set_root_path(root_path)
# run the summarizer
print(uts.run())
except Exception as e:
UnityTestSummary.usage(e)

2085
firmware/asdf/test/unity/unity.c Normal file
View File

File diff suppressed because it is too large Load Diff

617
firmware/asdf/test/unity/unity.h Normal file
View File

@ -0,0 +1,617 @@
/* ==========================================
Unity Project - A Test Framework for C
Copyright (c) 2007-19 Mike Karlesky, Mark VanderVoord, Greg Williams
[Released under MIT License. Please refer to license.txt for details]
========================================== */
#ifndef UNITY_FRAMEWORK_H
#define UNITY_FRAMEWORK_H
#define UNITY
#define UNITY_VERSION_MAJOR 2
#define UNITY_VERSION_MINOR 5
#define UNITY_VERSION_BUILD 0
#define UNITY_VERSION ((UNITY_VERSION_MAJOR << 16) | (UNITY_VERSION_MINOR << 8) | UNITY_VERSION_BUILD)
#ifdef __cplusplus
extern "C"
{
#endif
#include "unity_internals.h"
/*-------------------------------------------------------
* Test Setup / Teardown
*-------------------------------------------------------*/
/* These functions are intended to be called before and after each test.
* If using unity directly, these will need to be provided for each test
* executable built. If you are using the test runner generator and/or
* Ceedling, these are optional. */
void setUp(void);
void tearDown(void);
/* These functions are intended to be called at the beginning and end of an
* entire test suite. suiteTearDown() is passed the number of tests that
* failed, and its return value becomes the exit code of main(). If using
* Unity directly, you're in charge of calling these if they are desired.
* If using Ceedling or the test runner generator, these will be called
* automatically if they exist. */
void suiteSetUp(void);
int suiteTearDown(int num_failures);
/*-------------------------------------------------------
* Test Reset and Verify
*-------------------------------------------------------*/
/* These functions are intended to be called before during tests in order
* to support complex test loops, etc. Both are NOT built into Unity. Instead
* the test runner generator will create them. resetTest will run teardown and
* setup again, verifying any end-of-test needs between. verifyTest will only
* run the verification. */
void resetTest(void);
void verifyTest(void);
/*-------------------------------------------------------
* Configuration Options
*-------------------------------------------------------
* All options described below should be passed as a compiler flag to all files using Unity. If you must add #defines, place them BEFORE the #include above.
* Integers/longs/pointers
* - Unity attempts to automatically discover your integer sizes
* - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in <stdint.h>
* - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in <limits.h>
* - If you cannot use the automatic methods above, you can force Unity by using these options:
* - define UNITY_SUPPORT_64
* - set UNITY_INT_WIDTH
* - set UNITY_LONG_WIDTH
* - set UNITY_POINTER_WIDTH
* Floats
* - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons
* - define UNITY_FLOAT_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_FLOAT
* - define UNITY_FLOAT_TYPE to specify doubles instead of single precision floats
* - define UNITY_INCLUDE_DOUBLE to allow double floating point comparisons
* - define UNITY_EXCLUDE_DOUBLE to disallow double floating point comparisons (default)
* - define UNITY_DOUBLE_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_DOUBLE
* - define UNITY_DOUBLE_TYPE to specify something other than double
* - define UNITY_EXCLUDE_FLOAT_PRINT to trim binary size, won't print floating point values in errors
* Output
* - by default, Unity prints to standard out with putchar. define UNITY_OUTPUT_CHAR(a) with a different function if desired
* - define UNITY_DIFFERENTIATE_FINAL_FAIL to print FAILED (vs. FAIL) at test end summary - for automated search for failure
* Optimization
* - by default, line numbers are stored in unsigned shorts. Define UNITY_LINE_TYPE with a different type if your files are huge
* - by default, test and failure counters are unsigned shorts. Define UNITY_COUNTER_TYPE with a different type if you want to save space or have more than 65535 Tests.
* Test Cases
* - define UNITY_SUPPORT_TEST_CASES to include the TEST_CASE macro, though really it's mostly about the runner generator script
* Parameterized Tests
* - you'll want to create a define of TEST_CASE(...) which basically evaluates to nothing
* Tests with Arguments
* - you'll want to define UNITY_USE_COMMAND_LINE_ARGS if you have the test runner passing arguments to Unity
*-------------------------------------------------------
* Basic Fail and Ignore
*-------------------------------------------------------*/
#define TEST_FAIL_MESSAGE(message) UNITY_TEST_FAIL(__LINE__, (message))
#define TEST_FAIL() UNITY_TEST_FAIL(__LINE__, NULL)
#define TEST_IGNORE_MESSAGE(message) UNITY_TEST_IGNORE(__LINE__, (message))
#define TEST_IGNORE() UNITY_TEST_IGNORE(__LINE__, NULL)
#define TEST_MESSAGE(message) UnityMessage((message), __LINE__)
#define TEST_ONLY()
/* It is not necessary for you to call PASS. A PASS condition is assumed if nothing fails.
* This method allows you to abort a test immediately with a PASS state, ignoring the remainder of the test. */
#define TEST_PASS() TEST_ABORT()
#define TEST_PASS_MESSAGE(message) do { UnityMessage((message), __LINE__); TEST_ABORT(); } while(0)
/* This macro does nothing, but it is useful for build tools (like Ceedling) to make use of this to figure out
* which files should be linked to in order to perform a test. Use it like TEST_FILE("sandwiches.c") */
#define TEST_FILE(a)
/*-------------------------------------------------------
* Test Asserts (simple)
*-------------------------------------------------------*/
/* Boolean */
#define TEST_ASSERT(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expression Evaluated To FALSE")
#define TEST_ASSERT_TRUE(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expected TRUE Was FALSE")
#define TEST_ASSERT_UNLESS(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expression Evaluated To TRUE")
#define TEST_ASSERT_FALSE(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expected FALSE Was TRUE")
#define TEST_ASSERT_NULL(pointer) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, " Expected NULL")
#define TEST_ASSERT_NOT_NULL(pointer) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, " Expected Non-NULL")
/* Integers (of all sizes) */
#define TEST_ASSERT_EQUAL_INT(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_INT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_INT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_INT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_INT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_UINT(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_UINT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_UINT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_UINT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_UINT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_size_t(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_HEX(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_HEX8(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_HEX16(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_HEX32(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_HEX64(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_CHAR(expected, actual) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_BITS(mask, expected, actual) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_BITS_HIGH(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(-1), (actual), __LINE__, NULL)
#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (actual), __LINE__, NULL)
#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, NULL)
#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, NULL)
/* Integer Greater Than/ Less Than (of all sizes) */
#define TEST_ASSERT_GREATER_THAN(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_INT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_INT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_INT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_UINT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_INT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_INT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_INT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_INT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_UINT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_UINT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_UINT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_UINT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_HEX8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_HEX16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_HEX32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_LESS_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL)
/* Integer Ranges (of all sizes) */
#define TEST_ASSERT_INT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_INT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_INT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_INT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_INT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_UINT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_UINT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_UINT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_UINT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_UINT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_size_t_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_HEX_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_HEX8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_HEX16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_HEX32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_HEX64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_CHAR_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, NULL)
/* Integer Array Ranges (of all sizes) */
#define TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_size_t_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_HEX_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
#define TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
/* Structs and Strings */
#define TEST_ASSERT_EQUAL_PTR(expected, actual) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_STRING(expected, actual) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, NULL)
/* Arrays */
#define TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_size_t_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_HEX_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_CHAR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
/* Arrays Compared To Single Value */
#define TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_size_t(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_HEX(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, NULL)
/* Floating Point (If Enabled) */
#define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_FLOAT_IS_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, NULL)
#define TEST_ASSERT_FLOAT_IS_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, NULL)
#define TEST_ASSERT_FLOAT_IS_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, NULL)
#define TEST_ASSERT_FLOAT_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, NULL)
#define TEST_ASSERT_FLOAT_IS_NOT_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, NULL)
#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, NULL)
#define TEST_ASSERT_FLOAT_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, NULL)
#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, NULL)
/* Double (If Enabled) */
#define TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, NULL)
#define TEST_ASSERT_DOUBLE_IS_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, NULL)
#define TEST_ASSERT_DOUBLE_IS_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, NULL)
#define TEST_ASSERT_DOUBLE_IS_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, NULL)
#define TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, NULL)
#define TEST_ASSERT_DOUBLE_IS_NOT_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, NULL)
#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, NULL)
#define TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, NULL)
#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, NULL)
/* Shorthand */
#ifdef UNITY_SHORTHAND_AS_OLD
#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal")
#endif
#ifdef UNITY_SHORTHAND_AS_INT
#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
#endif
#ifdef UNITY_SHORTHAND_AS_MEM
#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
#endif
#ifdef UNITY_SHORTHAND_AS_RAW
#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, " Expected Equal")
#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal")
#endif
#ifdef UNITY_SHORTHAND_AS_NONE
#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
#endif
/*-------------------------------------------------------
* Test Asserts (with additional messages)
*-------------------------------------------------------*/
/* Boolean */
#define TEST_ASSERT_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message))
#define TEST_ASSERT_TRUE_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message))
#define TEST_ASSERT_UNLESS_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message))
#define TEST_ASSERT_FALSE_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message))
#define TEST_ASSERT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, (message))
#define TEST_ASSERT_NOT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, (message))
/* Integers (of all sizes) */
#define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_INT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_INT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_INT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_INT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_UINT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_UINT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_UINT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_size_t_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_HEX64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_BITS_MESSAGE(mask, expected, actual, message) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(-1), (actual), __LINE__, (message))
#define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (actual), __LINE__, (message))
#define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, (message))
#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_CHAR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, (message))
/* Integer Greater Than/ Less Than (of all sizes) */
#define TEST_ASSERT_GREATER_THAN_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_LESS_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message))
/* Integer Ranges (of all sizes) */
#define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_INT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_INT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_INT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_INT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_UINT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_UINT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_UINT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_UINT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_UINT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_size_t_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_HEX_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_HEX8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_HEX16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_HEX32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_HEX64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_CHAR_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, (message))
/* Integer Array Ranges (of all sizes) */
#define TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_INT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_UINT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_size_t_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_HEX_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
#define TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
/* Structs and Strings */
#define TEST_ASSERT_EQUAL_PTR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, (message))
#define TEST_ASSERT_EQUAL_MEMORY_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, (message))
/* Arrays */
#define TEST_ASSERT_EQUAL_INT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_INT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_INT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_INT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_INT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_UINT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_UINT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_UINT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_size_t_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_HEX_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_HEX16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_HEX32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_HEX64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_PTR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_STRING_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EQUAL_CHAR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
/* Arrays Compared To Single Value*/
#define TEST_ASSERT_EACH_EQUAL_INT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_INT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_INT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_INT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_INT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_UINT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_UINT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_UINT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_UINT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_UINT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_size_t_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_HEX_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_HEX8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_HEX16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_HEX32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_HEX64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_PTR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_STRING_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_MEMORY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_CHAR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, (message))
/* Floating Point (If Enabled) */
#define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_FLOAT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_FLOAT_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, (message))
#define TEST_ASSERT_FLOAT_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, (message))
#define TEST_ASSERT_FLOAT_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, (message))
#define TEST_ASSERT_FLOAT_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, (message))
#define TEST_ASSERT_FLOAT_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, (message))
#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, (message))
#define TEST_ASSERT_FLOAT_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, (message))
#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, (message))
/* Double (If Enabled) */
#define TEST_ASSERT_DOUBLE_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_EACH_EQUAL_DOUBLE_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, (message))
#define TEST_ASSERT_DOUBLE_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, (message))
#define TEST_ASSERT_DOUBLE_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, (message))
#define TEST_ASSERT_DOUBLE_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, (message))
#define TEST_ASSERT_DOUBLE_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, (message))
#define TEST_ASSERT_DOUBLE_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, (message))
#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, (message))
#define TEST_ASSERT_DOUBLE_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, (message))
#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, (message))
/* Shorthand */
#ifdef UNITY_SHORTHAND_AS_OLD
#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, (message))
#endif
#ifdef UNITY_SHORTHAND_AS_INT
#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, message)
#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
#endif
#ifdef UNITY_SHORTHAND_AS_MEM
#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, message)
#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
#endif
#ifdef UNITY_SHORTHAND_AS_RAW
#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, message)
#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, message)
#endif
#ifdef UNITY_SHORTHAND_AS_NONE
#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
#endif
/* end of UNITY_FRAMEWORK_H */
#ifdef __cplusplus
}
#endif
#endif

1002
firmware/asdf/test/unity/unity_internals.h Normal file
View File

File diff suppressed because it is too large Load Diff

15
hardware/common/unikbd.lib Normal file
View File

@ -0,0 +1,15 @@
EESchema-LIBRARY Version 2.4
#encoding utf-8
#
# Cherry_MX_LED
#
DEF Cherry_MX_LED SW** 0 0 N N 1 F N
F0 "SW**" 0 200 50 H V C CNN
F1 "Cherry_MX_LED" 0 -250 50 H V C CNN
F2 "" 0 0 50 H I C CNN
F3 "" 0 0 50 H I C CNN
DRAW
ENDDRAW
ENDDEF
#
#End Library

12
hardware/common/unikbd.pretty/Cherry aligner.kicad_mod Normal file
View File

@ -0,0 +1,12 @@
(module "Cherry aligner" (layer F.Cu) (tedit 5DA626D6)
(fp_text reference "REF**" (at -5.0292 -7.7724) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text value "Cherry aligner" (at 0 7.9756) (layer B.Fab)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_line (start -6.985 6.985) (end 6.985 6.985) (layer Edge.Cuts) (width 0.12))
(fp_line (start -6.985 -6.985) (end 6.985 -6.985) (layer Edge.Cuts) (width 0.12))
(fp_line (start 6.985 6.985) (end 6.985 -6.985) (layer Edge.Cuts) (width 0.12))
(fp_line (start -6.985 -6.985) (end -6.985 6.985) (layer Edge.Cuts) (width 0.12))
)

49
hardware/common/unikbd.pretty/D_DO-35_SOD27_P7.62mm_Horizontal_bypassed.kicad_mod Normal file
View File

@ -0,0 +1,49 @@
(module D_DO-35_SOD27_P7.62mm_Horizontal_bypassed (layer F.Cu) (tedit 5DF278C4)
(descr "Diode, DO-35_SOD27 series, Axial, Horizontal, pin pitch=7.62mm, , length*diameter=4*2mm^2, , http://www.diodes.com/_files/packages/DO-35.pdf")
(tags "Diode DO-35_SOD27 series Axial Horizontal pin pitch 7.62mm length 4mm diameter 2mm")
(fp_text reference REF** (at 3.81 -2.12) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text value D_DO-35_SOD27_P7.62mm_Horizontal (at 3.81 2.12) (layer F.Fab)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text user K (at 0 -1.8) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text user K (at 0 -1.8) (layer F.Fab)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text user %R (at 4.11 0) (layer F.Fab)
(effects (font (size 0.8 0.8) (thickness 0.12)))
)
(fp_line (start 8.67 -1.25) (end -1.05 -1.25) (layer F.CrtYd) (width 0.05))
(fp_line (start 8.67 1.25) (end 8.67 -1.25) (layer F.CrtYd) (width 0.05))
(fp_line (start -1.05 1.25) (end 8.67 1.25) (layer F.CrtYd) (width 0.05))
(fp_line (start -1.05 -1.25) (end -1.05 1.25) (layer F.CrtYd) (width 0.05))
(fp_line (start 2.29 -1.12) (end 2.29 1.12) (layer F.SilkS) (width 0.12))
(fp_line (start 2.53 -1.12) (end 2.53 1.12) (layer F.SilkS) (width 0.12))
(fp_line (start 2.41 -1.12) (end 2.41 1.12) (layer F.SilkS) (width 0.12))
(fp_line (start 6.58 0) (end 5.93 0) (layer F.SilkS) (width 0.12))
(fp_line (start 1.04 0) (end 1.69 0) (layer F.SilkS) (width 0.12))
(fp_line (start 5.93 -1.12) (end 1.69 -1.12) (layer F.SilkS) (width 0.12))
(fp_line (start 5.93 1.12) (end 5.93 -1.12) (layer F.SilkS) (width 0.12))
(fp_line (start 1.69 1.12) (end 5.93 1.12) (layer F.SilkS) (width 0.12))
(fp_line (start 1.69 -1.12) (end 1.69 1.12) (layer F.SilkS) (width 0.12))
(fp_line (start 2.31 -1) (end 2.31 1) (layer F.Fab) (width 0.1))
(fp_line (start 2.51 -1) (end 2.51 1) (layer F.Fab) (width 0.1))
(fp_line (start 2.41 -1) (end 2.41 1) (layer F.Fab) (width 0.1))
(fp_line (start 7.62 0) (end 5.81 0) (layer F.Fab) (width 0.1))
(fp_line (start 0 0) (end 1.81 0) (layer F.Fab) (width 0.1))
(fp_line (start 5.81 -1) (end 1.81 -1) (layer F.Fab) (width 0.1))
(fp_line (start 5.81 1) (end 5.81 -1) (layer F.Fab) (width 0.1))
(fp_line (start 1.81 1) (end 5.81 1) (layer F.Fab) (width 0.1))
(fp_line (start 1.81 -1) (end 1.81 1) (layer F.Fab) (width 0.1))
(fp_poly (pts (xy 7.239 0.127) (xy 0.381 0.127) (xy 0.381 0) (xy 7.239 0)) (layer F.Cu) (width 0.0508))
(pad 2 thru_hole oval (at 7.62 0) (size 1.6 1.6) (drill 0.8) (layers *.Cu *.Mask))
(pad 1 thru_hole rect (at 0 0) (size 1.6 1.6) (drill 0.8) (layers *.Cu *.Mask))
(model ${KISYS3DMOD}/Diode_THT.3dshapes/D_DO-35_SOD27_P7.62mm_Horizontal.wrl
(at (xyz 0 0 0))
(scale (xyz 1 1 1))
(rotate (xyz 0 0 0))
)
)

13
hardware/common/unikbd.pretty/Futaba-MD-4PCS-aligner.kicad_mod Normal file
View File

@ -0,0 +1,13 @@
(module "Futaba-MD-4PCS-aligner" (layer F.Cu) (tedit 5DA63068)
(fp_text reference "REF**" (at -3.937 -8.3566) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text value "MD-4PCS-aligner" (at 0.1524 8.8646) (layer B.Fab)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_circle (center 0 0) (end 7.8232 0) (layer Edge.Cuts) (width 0.12))
(pad "" np_thru_hole circle (at 6.985 -6.985) (size 1.6256 1.6256) (drill 1.6256) (layers *.Cu *.Mask))
(pad "" np_thru_hole circle (at 6.985 6.985) (size 1.6256 1.6256) (drill 1.6256) (layers *.Cu *.Mask))
(pad "" np_thru_hole circle (at -6.985 6.985) (size 1.6256 1.6256) (drill 1.6256) (layers *.Cu *.Mask))
(pad "" np_thru_hole circle (at -6.985 -6.985) (size 1.6256 1.6256) (drill 1.6256) (layers *.Cu *.Mask))
)

24
hardware/common/unikbd.pretty/Key_MX.kicad_mod Normal file
View File

@ -0,0 +1,24 @@
(module "Key_MX" (layer F.Cu) (tedit 5DA6279D)
(fp_text reference "SW_**" (at -5.7912 -8.6106) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text value "Key_MX" (at -5.334 8.6614) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_line (start -7.874 7.874) (end -7.874 -7.874) (layer F.CrtYd) (width 0.12))
(fp_line (start 7.874 7.874) (end -7.874 7.874) (layer F.CrtYd) (width 0.12))
(fp_line (start 7.874 -7.874) (end 7.874 7.874) (layer F.CrtYd) (width 0.12))
(fp_line (start -7.874 -7.874) (end 7.874 -7.874) (layer F.CrtYd) (width 0.12))
(fp_line (start -3.81 -2.54) (end -2.54 0) (layer F.Cu) (width 0.3048))
(fp_line (start -2.54 0) (end -2.54 1.27) (layer F.Cu) (width 0.3048))
(fp_line (start -2.54 1.27) (end 0 3.81) (layer F.Cu) (width 0.3048))
(fp_line (start 1.651 -5.08) (end 1.27 -5.08) (layer F.Cu) (width 0.3048))
(fp_line (start 1.27 -5.08) (end 0.7366 -4.6736) (layer F.Cu) (width 0.3048))
(pad "4" thru_hole circle (at -3.81 -2.54) (size 2.2352 2.2352) (drill 1.5748) (layers *.Cu *.Mask))
(pad "" np_thru_hole circle (at 0 0) (size 3.9878 3.9878) (drill 3.9878) (layers *.Cu *.Mask))
(pad "" np_thru_hole circle (at 5.08 0) (size 1.7018 1.7018) (drill 1.7018) (layers *.Cu *.Mask))
(pad "" np_thru_hole circle (at -5.08 0) (size 1.7018 1.7018) (drill 1.7018) (layers *.Cu *.Mask))
(pad "3" thru_hole circle (at 2.54 -5.08) (size 2.2352 2.2352) (drill 1.5748) (layers *.Cu *.Mask))
(pad "1" thru_hole circle (at 0 -4.0005) (size 2.2352 2.2352) (drill 1.397) (layers *.Cu *.Mask))
(pad "2" thru_hole circle (at 0 4.0005) (size 2.2352 2.2352) (drill 1.397) (layers *.Cu *.Mask))
)

26
hardware/common/unikbd.pretty/Key_MX_LED.kicad_mod Normal file
View File

@ -0,0 +1,26 @@
(module Key_MX_LED (layer F.Cu) (tedit 5DF12B03)
(fp_text reference SW_** (at -5.7912 -8.6106) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text value Key_MX (at -5.334 8.6614) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_line (start -7.874 7.874) (end -7.874 -7.874) (layer F.CrtYd) (width 0.12))
(fp_line (start 7.874 7.874) (end -7.874 7.874) (layer F.CrtYd) (width 0.12))
(fp_line (start 7.874 -7.874) (end 7.874 7.874) (layer F.CrtYd) (width 0.12))
(fp_line (start -7.874 -7.874) (end 7.874 -7.874) (layer F.CrtYd) (width 0.12))
(fp_line (start -3.81 -2.54) (end -2.54 0) (layer F.Cu) (width 0.3048))
(fp_line (start -2.54 0) (end -2.54 1.27) (layer F.Cu) (width 0.3048))
(fp_line (start -2.54 1.27) (end 0 3.81) (layer F.Cu) (width 0.3048))
(fp_line (start 1.651 -5.08) (end 1.27 -5.08) (layer F.Cu) (width 0.3048))
(fp_line (start 1.27 -5.08) (end 0.7366 -4.6736) (layer F.Cu) (width 0.3048))
(pad 5 thru_hole circle (at -3.81 -2.54) (size 2.2352 2.2352) (drill 1.5748) (layers *.Cu *.Mask))
(pad "" np_thru_hole circle (at 0 0) (size 3.9878 3.9878) (drill 3.9878) (layers *.Cu *.Mask))
(pad "" np_thru_hole circle (at 5.08 0) (size 1.7018 1.7018) (drill 1.7018) (layers *.Cu *.Mask))
(pad "" np_thru_hole circle (at -5.08 0) (size 1.7018 1.7018) (drill 1.7018) (layers *.Cu *.Mask))
(pad 6 thru_hole circle (at 2.54 -5.08) (size 2.2352 2.2352) (drill 1.5748) (layers *.Cu *.Mask))
(pad 1 thru_hole circle (at 0 -4.0005) (size 2.2352 2.2352) (drill 1.397) (layers *.Cu *.Mask))
(pad 2 thru_hole circle (at 0 4.0005) (size 1.651 1.651) (drill 1.397) (layers *.Cu *.Mask))
(pad 4 thru_hole circle (at 1.27 5.08) (size 1.27 1.27) (drill 1.0668) (layers *.Cu *.Mask))
(pad 3 thru_hole circle (at -1.27 5.08) (size 1.27 1.27) (drill 1.0668) (layers *.Cu *.Mask))
)

12
hardware/common/unikbd.pretty/MX_space_align.mod Normal file
View File

@ -0,0 +1,12 @@
(module "Cherry aligner" (layer F.Cu) (tedit 5D993F00)
(fp_text reference "REF**" (at -3.81 -6.858) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text value "Cherry aligner" (at -0.508 6.985) (layer B.Fab)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_line (start -5.715 -5.715) (end -5.715 5.715) (layer Edge.Cuts) (width 0.12))
(fp_line (start 5.715 5.715) (end 5.715 -5.715) (layer Edge.Cuts) (width 0.12))
(fp_line (start -5.715 -5.715) (end 5.715 -5.715) (layer Edge.Cuts) (width 0.12))
(fp_line (start -5.715 5.715) (end 5.715 5.715) (layer Edge.Cuts) (width 0.12))
)

44
hardware/common/unikbd.pretty/MX_space_aligner.kicad_mod Normal file
View File

@ -0,0 +1,44 @@
(module "MX_space_aligner" (layer F.Cu) (tedit 5DA62851)
(fp_text reference "SW**" (at -5.334 -7.874) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text value "MX_space_aligner" (at -0.6096 7.9248) (layer B.Fab)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_line (start 6.985 -6.985) (end 6.985 -1.397) (layer Edge.Cuts) (width 0.12))
(fp_line (start 6.985 -1.397) (end 63.3476 -1.397) (layer Edge.Cuts) (width 0.12))
(fp_line (start 63.3476 -1.397) (end 63.3476 -5.6896) (layer Edge.Cuts) (width 0.12))
(fp_line (start 63.3476 -5.6896) (end 70.0024 -5.6896) (layer Edge.Cuts) (width 0.12))
(fp_line (start 70.0024 -5.6896) (end 70.0024 -2.286) (layer Edge.Cuts) (width 0.12))
(fp_line (start 70.0024 -2.286) (end 70.866 -2.286) (layer Edge.Cuts) (width 0.12))
(fp_line (start 70.866 -2.286) (end 70.866 0.508) (layer Edge.Cuts) (width 0.12))
(fp_line (start 70.866 0.508) (end 70.0024 0.508) (layer Edge.Cuts) (width 0.12))
(fp_line (start 70.0024 0.508) (end 70.0024 6.604) (layer Edge.Cuts) (width 0.12))
(fp_line (start 70.0024 6.604) (end 68.199 6.604) (layer Edge.Cuts) (width 0.12))
(fp_line (start 68.199 6.604) (end 68.199 7.7724) (layer Edge.Cuts) (width 0.12))
(fp_line (start 68.199 7.7724) (end 65.151 7.7724) (layer Edge.Cuts) (width 0.12))
(fp_line (start 65.151 7.7724) (end 65.151 6.604) (layer Edge.Cuts) (width 0.12))
(fp_line (start 65.151 6.604) (end 63.3476 6.604) (layer Edge.Cuts) (width 0.12))
(fp_line (start 63.3476 6.604) (end 63.3476 1.397) (layer Edge.Cuts) (width 0.12))
(fp_line (start 63.3476 1.397) (end 6.985 1.397) (layer Edge.Cuts) (width 0.12))
(fp_line (start 6.985 1.397) (end 6.985 6.985) (layer Edge.Cuts) (width 0.12))
(fp_line (start 6.985 6.985) (end -6.985 6.985) (layer Edge.Cuts) (width 0.12))
(fp_line (start -6.985 6.985) (end -6.985 1.397) (layer Edge.Cuts) (width 0.12))
(fp_line (start -6.985 1.397) (end -63.3476 1.397) (layer Edge.Cuts) (width 0.12))
(fp_line (start -63.3476 1.397) (end -63.3476 6.604) (layer Edge.Cuts) (width 0.12))
(fp_line (start -63.3476 6.604) (end -65.151 6.604) (layer Edge.Cuts) (width 0.12))
(fp_line (start -65.151 6.604) (end -65.151 7.7724) (layer Edge.Cuts) (width 0.12))
(fp_line (start -65.151 7.7724) (end -68.199 7.7724) (layer Edge.Cuts) (width 0.12))
(fp_line (start -68.199 7.7724) (end -68.199 6.604) (layer Edge.Cuts) (width 0.12))
(fp_line (start -68.199 6.604) (end -70.0024 6.604) (layer Edge.Cuts) (width 0.12))
(fp_line (start -70.0024 6.604) (end -70.0024 0.508) (layer Edge.Cuts) (width 0.12))
(fp_line (start -70.0024 0.508) (end -70.866 0.508) (layer Edge.Cuts) (width 0.12))
(fp_line (start -70.866 0.508) (end -70.866 -2.286) (layer Edge.Cuts) (width 0.12))
(fp_line (start -70.866 -2.286) (end -70.0024 -2.286) (layer Edge.Cuts) (width 0.12))
(fp_line (start -70.0024 -2.286) (end -70.0024 -5.6896) (layer Edge.Cuts) (width 0.12))
(fp_line (start -70.0024 -5.6896) (end -63.3476 -5.6896) (layer Edge.Cuts) (width 0.12))
(fp_line (start -63.3476 -5.6896) (end -63.3476 -1.397) (layer Edge.Cuts) (width 0.12))
(fp_line (start -63.3476 -1.397) (end -6.985 -1.397) (layer Edge.Cuts) (width 0.12))
(fp_line (start -6.985 -1.397) (end -6.985 -6.985) (layer Edge.Cuts) (width 0.12))
(fp_line (start -6.985 -6.985) (end 6.985 -6.985) (layer Edge.Cuts) (width 0.12))
)

17
hardware/common/unikbd.pretty/MountingHole_3.5mm.kicad_mod Normal file
View File

@ -0,0 +1,17 @@
(module MountingHole_3.5mm (layer F.Cu) (tedit 56D1B4CB)
(descr "Mounting Hole 3.5mm, no annular")
(tags "mounting hole 3.5mm no annular")
(attr virtual)
(fp_text reference REF** (at 0 -4.5) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text value MountingHole_3.5mm (at 0 4.5) (layer F.Fab)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_circle (center 0 0) (end 3.75 0) (layer F.CrtYd) (width 0.05))
(fp_circle (center 0 0) (end 3.5 0) (layer Cmts.User) (width 0.15))
(fp_text user %R (at 0.3 0) (layer F.Fab)
(effects (font (size 1 1) (thickness 0.15)))
)
(pad 1 np_thru_hole circle (at 0 0) (size 3.5 3.5) (drill 3.5) (layers *.Cu *.Mask))
)

75
hardware/common/unikbd.pretty/PinHeader_2x20_P2.54mm_Vertical.kicad_mod Normal file
View File

@ -0,0 +1,75 @@
(module PinHeader_2x20_P2.54mm_Vertical (layer F.Cu) (tedit 5DEFFCEB)
(descr "Through hole straight pin header, 2x20, 2.54mm pitch, double rows")
(tags "Through hole pin header THT 2x20 2.54mm double row")
(fp_text reference REF** (at 1.2954 -2.5078) (layer F.SilkS)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_text value PinHeader_2x20_P2.54mm_Vertical (at 1.27 50.59) (layer F.Fab)
(effects (font (size 1 1) (thickness 0.15)))
)
(fp_line (start 2.5654 -1.4478) (end -1.2446 -1.4478) (layer F.Fab) (width 0.1))
(fp_line (start -1.2446 -1.4478) (end -1.2446 49.3522) (layer F.Fab) (width 0.1))
(fp_line (start -1.2446 49.3522) (end 3.8354 49.3522) (layer F.Fab) (width 0.1))
(fp_line (start 3.8354 49.3522) (end 3.8354 -0.1778) (layer F.Fab) (width 0.1))
(fp_line (start 3.8354 -0.1778) (end 2.5654 -1.4478) (layer F.Fab) (width 0.1))
(fp_line (start 3.8954 49.4122) (end -1.3046 49.4122) (layer F.SilkS) (width 0.12))
(fp_line (start 3.8954 1.0922) (end 3.8954 49.4122) (layer F.SilkS) (width 0.12))
(fp_line (start -1.3046 -1.5078) (end -1.3046 49.4122) (layer F.SilkS) (width 0.12))
(fp_line (start 3.8954 1.0922) (end 1.2954 1.0922) (layer F.SilkS) (width 0.12))
(fp_line (start 1.2954 1.0922) (end 1.2954 -1.5078) (layer F.SilkS) (width 0.12))
(fp_line (start 1.2954 -1.5078) (end -1.3046 -1.5078) (layer F.SilkS) (width 0.12))
(fp_line (start 3.8954 -0.1778) (end 3.8954 -1.5078) (layer F.SilkS) (width 0.12))
(fp_line (start 3.8954 -1.5078) (end 2.5654 -1.5078) (layer F.SilkS) (width 0.12))
(fp_line (start 4.3654 -1.9778) (end 4.3654 49.8722) (layer F.CrtYd) (width 0.05))
(fp_line (start 4.3654 49.8722) (end -1.7846 49.8722) (layer F.CrtYd) (width 0.05))
(fp_line (start -1.7846 49.8722) (end -1.7846 -1.9778) (layer F.CrtYd) (width 0.05))
(fp_line (start -1.7846 -1.9778) (end 4.3654 -1.9778) (layer F.CrtYd) (width 0.05))
(fp_text user %R (at 1.2954 23.9522 90) (layer F.Fab)
(effects (font (size 1 1) (thickness 0.15)))
)
(pad 1 thru_hole rect (at 2.5654 -0.1778) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 2 thru_hole oval (at 0.0254 -0.1778) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 3 thru_hole oval (at 2.5654 2.3622) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 4 thru_hole oval (at 0.0254 2.3622) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 5 thru_hole oval (at 2.5654 4.9022) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 6 thru_hole oval (at 0.0254 4.9022) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 7 thru_hole oval (at 2.5654 7.4422) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 8 thru_hole oval (at 0.0254 7.4422) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 9 thru_hole oval (at 2.5654 9.9822) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 10 thru_hole oval (at 0.0254 9.9822) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 11 thru_hole oval (at 2.5654 12.5222) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 12 thru_hole oval (at 0.0254 12.5222) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 13 thru_hole oval (at 2.5654 15.0622) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 14 thru_hole oval (at 0.0254 15.0622) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 15 thru_hole oval (at 2.5654 17.6022) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 16 thru_hole oval (at 0.0254 17.6022) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 17 thru_hole oval (at 2.5654 20.1422) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 18 thru_hole oval (at 0.0254 20.1422) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 19 thru_hole oval (at 2.5654 22.6822) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 20 thru_hole oval (at 0.0254 22.6822) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 21 thru_hole oval (at 2.5654 25.2222) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 22 thru_hole oval (at 0.0254 25.2222) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 23 thru_hole oval (at 2.5654 27.7622) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 24 thru_hole oval (at 0.0254 27.7622) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 25 thru_hole oval (at 2.5654 30.3022) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 26 thru_hole oval (at 0.0254 30.3022) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 27 thru_hole oval (at 2.5654 32.8422) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 28 thru_hole oval (at 0.0254 32.8422) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 29 thru_hole oval (at 2.5654 35.3822) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 30 thru_hole oval (at 0.0254 35.3822) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 31 thru_hole oval (at 2.5654 37.9222) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 32 thru_hole oval (at 0.0254 37.9222) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 33 thru_hole oval (at 2.5654 40.4622) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 34 thru_hole oval (at 0.0254 40.4622) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 35 thru_hole oval (at 2.5654 43.0022) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 36 thru_hole oval (at 0.0254 43.0022) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 37 thru_hole oval (at 2.5654 45.5422) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 38 thru_hole oval (at 0.0254 45.5422) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 39 thru_hole oval (at 2.5654 48.0822) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(pad 40 thru_hole oval (at 0.0254 48.0822) (size 1.7 1.7) (drill 1) (layers *.Cu *.Mask))
(model ${KISYS3DMOD}/Connector_PinHeader_2.54mm.3dshapes/PinHeader_2x20_P2.54mm_Vertical.wrl
(at (xyz 0 0 0))
(scale (xyz 1 1 1))
(rotate (xyz 0 0 0))
)
)

4055
hardware/interface-ascii/interface-ascii.kicad_pcb Normal file
View File

File diff suppressed because it is too large Load Diff

78
hardware/interface-ascii/interface-ascii.lib Normal file
View File

@ -0,0 +1,78 @@
EESchema-LIBRARY Version 2.4
#encoding utf-8
#
# 74LS166
#
DEF 74LS166 U 0 40 Y Y 1 L N
F0 "U" -300 850 50 H V C CNN
F1 "74LS166" -300 -850 50 H V C CNN
F2 "" 0 0 50 H I C CNN
F3 "" 0 0 50 H I C CNN
$FPLIST
DIP?16*
$ENDFPLIST
DRAW
S -300 800 300 -800 1 1 10 f
X Ds 1 -500 700 200 R 50 50 1 0 I
X D3 10 500 200 200 L 50 50 1 0 I
X D2 11 500 100 200 L 50 50 1 0 I
X D1 12 500 0 200 L 50 50 1 0 I
X Qh 13 -500 200 200 R 50 50 1 0 O
X D0 14 500 -100 200 L 50 50 1 0 I
X SH_~LD 15 -500 50 200 R 50 50 1 0 I
X VCC 16 0 1000 200 D 50 50 1 0 W
X D7 2 500 600 200 L 50 50 1 0 I
X D6 3 500 500 200 L 50 50 1 0 I
X D5 4 500 400 200 L 50 50 1 0 I
X D4 5 500 300 200 L 50 50 1 0 I
X CK_INH 6 -500 -500 200 R 50 50 1 0 I
X CLK 7 -500 -100 200 R 50 50 1 0 I C
X GND 8 0 -1000 200 U 50 50 1 0 W
X Clr 9 -500 600 200 R 50 50 1 0 I I
ENDDRAW
ENDDEF
#
# ATmega328P-PU-MCU_Microchip_ATmega
#
DEF ATmega328P-PU-MCU_Microchip_ATmega U 0 20 Y Y 1 F N
F0 "U" -500 1450 50 H V L BNN
F1 "ATmega328P-PU-MCU_Microchip_ATmega" 100 -1450 50 H V L TNN
F2 "Package_DIP:DIP-28_W7.62mm" 0 0 50 H I C CIN
F3 "" 0 0 50 H I C CNN
$FPLIST
DIP*W7.62mm*
$ENDFPLIST
DRAW
S -500 -1400 500 1400 0 1 10 f
X ~RESET 1 600 -300 100 L 50 50 1 1 T
X PB7 10 600 500 100 L 50 50 1 1 T
X PD5 11 600 -1000 100 L 50 50 1 1 T
X PD6 12 600 -1100 100 L 50 50 1 1 T
X PD7 13 600 -1200 100 L 50 50 1 1 T
X PB0 14 600 1200 100 L 50 50 1 1 T
X PB1 15 600 1100 100 L 50 50 1 1 T
X PB2 16 600 1000 100 L 50 50 1 1 T
X MOSI 17 600 900 100 L 50 50 1 1 T
X MISO 18 600 800 100 L 50 50 1 1 T
X SCK 19 600 700 100 L 50 50 1 1 T
X PD0 2 600 -500 100 L 50 50 1 1 T
X AVCC 20 100 1500 100 D 50 50 1 1 W
X AREF 21 -600 1200 100 R 50 50 1 1 P
X GND 22 0 -1500 100 U 50 50 1 1 P N
X PC0 23 600 300 100 L 50 50 1 1 T
X PC1 24 600 200 100 L 50 50 1 1 T
X PC2 25 600 100 100 L 50 50 1 1 T
X PC3 26 600 0 100 L 50 50 1 1 T
X PC4 27 600 -100 100 L 50 50 1 1 T
X PC5 28 600 -200 100 L 50 50 1 1 T
X PD1 3 600 -600 100 L 50 50 1 1 T
X PD2 4 600 -700 100 L 50 50 1 1 T
X PD3 5 600 -800 100 L 50 50 1 1 T
X PD4 6 600 -900 100 L 50 50 1 1 T
X VCC 7 0 1500 100 D 50 50 1 1 W
X GND 8 0 -1500 100 U 50 50 1 1 W
X PB6 9 600 600 100 L 50 50 1 1 T
ENDDRAW
ENDDEF
#
#End Library

281
hardware/interface-ascii/interface-ascii.pro Normal file
View File

@ -0,0 +1,281 @@
update=Saturday, November 23, 2019 at 09:32:10 AM
version=1
last_client=kicad
[general]
version=1
RootSch=
BoardNm=
[cvpcb]
version=1
NetIExt=net
[eeschema]
version=1
LibDir=
[eeschema/libraries]
[pcbnew]
version=1
PageLayoutDescrFile=
LastNetListRead=unikbd.net
CopperLayerCount=2
BoardThickness=1.6
AllowMicroVias=0
AllowBlindVias=0
RequireCourtyardDefinitions=0
ProhibitOverlappingCourtyards=1
MinTrackWidth=0.2
MinViaDiameter=0.4
MinViaDrill=0.3
MinMicroViaDiameter=0.2
MinMicroViaDrill=0.09999999999999999
MinHoleToHole=0.25
TrackWidth1=0.254
TrackWidth2=0.254
TrackWidth3=0.508
TrackWidth4=1.27
ViaDiameter1=0.8128
ViaDrill1=0.4064
ViaDiameter2=1.27
ViaDrill2=0.7112
dPairWidth1=0.2032
dPairGap1=0.254
dPairViaGap1=0.25
SilkLineWidth=0.15
SilkTextSizeV=1
SilkTextSizeH=1
SilkTextSizeThickness=0.15
SilkTextItalic=0
SilkTextUpright=1
CopperLineWidth=0.2
CopperTextSizeV=1.5
CopperTextSizeH=1.5
CopperTextThickness=0.3
CopperTextItalic=0
CopperTextUpright=1
EdgeCutLineWidth=0.09999999999999999
CourtyardLineWidth=0.05
OthersLineWidth=0.15
OthersTextSizeV=1
OthersTextSizeH=1
OthersTextSizeThickness=0.15
OthersTextItalic=0
OthersTextUpright=1
SolderMaskClearance=0
SolderMaskMinWidth=0
SolderPasteClearance=0
SolderPasteRatio=-0
[pcbnew/Layer.F.Cu]
Name=F.Cu
Type=0
Enabled=1
[pcbnew/Layer.In1.Cu]
Name=In1.Cu
Type=0
Enabled=0
[pcbnew/Layer.In2.Cu]
Name=In2.Cu
Type=0
Enabled=0
[pcbnew/Layer.In3.Cu]
Name=In3.Cu
Type=0
Enabled=0
[pcbnew/Layer.In4.Cu]
Name=In4.Cu
Type=0
Enabled=0
[pcbnew/Layer.In5.Cu]
Name=In5.Cu
Type=0
Enabled=0
[pcbnew/Layer.In6.Cu]
Name=In6.Cu
Type=0
Enabled=0
[pcbnew/Layer.In7.Cu]
Name=In7.Cu
Type=0
Enabled=0
[pcbnew/Layer.In8.Cu]
Name=In8.Cu
Type=0
Enabled=0
[pcbnew/Layer.In9.Cu]
Name=In9.Cu
Type=0
Enabled=0
[pcbnew/Layer.In10.Cu]
Name=In10.Cu
Type=0
Enabled=0
[pcbnew/Layer.In11.Cu]
Name=In11.Cu
Type=0
Enabled=0
[pcbnew/Layer.In12.Cu]
Name=In12.Cu
Type=0
Enabled=0
[pcbnew/Layer.In13.Cu]
Name=In13.Cu
Type=0
Enabled=0
[pcbnew/Layer.In14.Cu]
Name=In14.Cu
Type=0
Enabled=0
[pcbnew/Layer.In15.Cu]
Name=In15.Cu
Type=0
Enabled=0
[pcbnew/Layer.In16.Cu]
Name=In16.Cu
Type=0
Enabled=0
[pcbnew/Layer.In17.Cu]
Name=In17.Cu
Type=0
Enabled=0
[pcbnew/Layer.In18.Cu]
Name=In18.Cu
Type=0
Enabled=0
[pcbnew/Layer.In19.Cu]
Name=In19.Cu
Type=0
Enabled=0
[pcbnew/Layer.In20.Cu]
Name=In20.Cu
Type=0
Enabled=0
[pcbnew/Layer.In21.Cu]
Name=In21.Cu
Type=0
Enabled=0
[pcbnew/Layer.In22.Cu]
Name=In22.Cu
Type=0
Enabled=0
[pcbnew/Layer.In23.Cu]
Name=In23.Cu
Type=0
Enabled=0
[pcbnew/Layer.In24.Cu]
Name=In24.Cu
Type=0
Enabled=0
[pcbnew/Layer.In25.Cu]
Name=In25.Cu
Type=0
Enabled=0
[pcbnew/Layer.In26.Cu]
Name=In26.Cu
Type=0
Enabled=0
[pcbnew/Layer.In27.Cu]
Name=In27.Cu
Type=0
Enabled=0
[pcbnew/Layer.In28.Cu]
Name=In28.Cu
Type=0
Enabled=0
[pcbnew/Layer.In29.Cu]
Name=In29.Cu
Type=0
Enabled=0
[pcbnew/Layer.In30.Cu]
Name=In30.Cu
Type=0
Enabled=0
[pcbnew/Layer.B.Cu]
Name=B.Cu
Type=0
Enabled=1
[pcbnew/Layer.B.Adhes]
Enabled=1
[pcbnew/Layer.F.Adhes]
Enabled=1
[pcbnew/Layer.B.Paste]
Enabled=1
[pcbnew/Layer.F.Paste]
Enabled=1
[pcbnew/Layer.B.SilkS]
Enabled=1
[pcbnew/Layer.F.SilkS]
Enabled=1
[pcbnew/Layer.B.Mask]
Enabled=1
[pcbnew/Layer.F.Mask]
Enabled=1
[pcbnew/Layer.Dwgs.User]
Enabled=1
[pcbnew/Layer.Cmts.User]
Enabled=1
[pcbnew/Layer.Eco1.User]
Enabled=1
[pcbnew/Layer.Eco2.User]
Enabled=1
[pcbnew/Layer.Edge.Cuts]
Enabled=1
[pcbnew/Layer.Margin]
Enabled=1
[pcbnew/Layer.B.CrtYd]
Enabled=1
[pcbnew/Layer.F.CrtYd]
Enabled=1
[pcbnew/Layer.B.Fab]
Enabled=1
[pcbnew/Layer.F.Fab]
Enabled=1
[pcbnew/Layer.Rescue]
Enabled=0
[pcbnew/Netclasses]
[pcbnew/Netclasses/Default]
Name=Default
Clearance=0.2
TrackWidth=0.254
ViaDiameter=0.8128
ViaDrill=0.4064
uViaDiameter=0.3048
uViaDrill=0.1016
dPairWidth=0.2032
dPairGap=0.254
dPairViaGap=0.25
[pcbnew/Netclasses/1]
Name=power1
Clearance=0.254
TrackWidth=1.27
ViaDiameter=1.27
ViaDrill=0.7112
uViaDiameter=0.3048
uViaDrill=0.1016
dPairWidth=0.2032
dPairGap=0.254
dPairViaGap=0.25
[pcbnew/Netclasses/2]
Name=signal
Clearance=0.2032
TrackWidth=0.254
ViaDiameter=0.8128
ViaDrill=0.4064
uViaDiameter=0.3048
uViaDrill=0.1016
dPairWidth=0.2032
dPairGap=0.254
dPairViaGap=0.25
[schematic_editor]
version=1
PageLayoutDescrFile=
PlotDirectoryName=
SubpartIdSeparator=0
SubpartFirstId=65
NetFmtName=
SpiceAjustPassiveValues=0
LabSize=50
ERC_WriteFile=0
ERC_TestSimilarLabels=1
ERC_CheckUniqueGlobalLabels=1
ERC_CheckBusDriverConflicts=1
ERC_CheckBusEntryConflicts=1
ERC_CheckBusToBusConflicts=1
ERC_CheckBusToNetConflicts=1

1853
hardware/interface-ascii/interface-ascii.sch Normal file
View File

File diff suppressed because it is too large Load Diff

1551
hardware/interface-osi/unikbd-osi.kicad_pcb Normal file
View File

File diff suppressed because it is too large Load Diff

265
hardware/interface-osi/unikbd-osi.pro Normal file
View File

@ -0,0 +1,265 @@
update=6/24/2019 2:07:05 PM
version=1
last_client=kicad
[general]
version=1
RootSch=
BoardNm=
[cvpcb]
version=1
NetIExt=net
[eeschema]
version=1
LibDir=
[eeschema/libraries]
[pcbnew]
version=1
PageLayoutDescrFile=
LastNetListRead=unikbd.net
CopperLayerCount=2
BoardThickness=1.6
AllowMicroVias=0
AllowBlindVias=0
RequireCourtyardDefinitions=0
ProhibitOverlappingCourtyards=1
MinTrackWidth=0.2
MinViaDiameter=0.4
MinViaDrill=0.3
MinMicroViaDiameter=0.2
MinMicroViaDrill=0.09999999999999999
MinHoleToHole=0.25
TrackWidth1=0.254
TrackWidth2=0.254
TrackWidth3=0.508
TrackWidth4=1.27
ViaDiameter1=0.8128
ViaDrill1=0.4064
ViaDiameter2=1.27
ViaDrill2=0.7112
dPairWidth1=0.2032
dPairGap1=0.254
dPairViaGap1=0.25
SilkLineWidth=0.15
SilkTextSizeV=1
SilkTextSizeH=1
SilkTextSizeThickness=0.15
SilkTextItalic=0
SilkTextUpright=1
CopperLineWidth=0.2
CopperTextSizeV=1.5
CopperTextSizeH=1.5
CopperTextThickness=0.3
CopperTextItalic=0
CopperTextUpright=1
EdgeCutLineWidth=0.09999999999999999
CourtyardLineWidth=0.05
OthersLineWidth=0.15
OthersTextSizeV=1
OthersTextSizeH=1
OthersTextSizeThickness=0.15
OthersTextItalic=0
OthersTextUpright=1
SolderMaskClearance=0
SolderMaskMinWidth=0
SolderPasteClearance=0
SolderPasteRatio=-0
[pcbnew/Layer.F.Cu]
Name=F.Cu
Type=0
Enabled=1
[pcbnew/Layer.In1.Cu]
Name=In1.Cu
Type=0
Enabled=0
[pcbnew/Layer.In2.Cu]
Name=In2.Cu
Type=0
Enabled=0
[pcbnew/Layer.In3.Cu]
Name=In3.Cu
Type=0
Enabled=0
[pcbnew/Layer.In4.Cu]
Name=In4.Cu
Type=0
Enabled=0
[pcbnew/Layer.In5.Cu]
Name=In5.Cu
Type=0
Enabled=0
[pcbnew/Layer.In6.Cu]
Name=In6.Cu
Type=0
Enabled=0
[pcbnew/Layer.In7.Cu]
Name=In7.Cu
Type=0
Enabled=0
[pcbnew/Layer.In8.Cu]
Name=In8.Cu
Type=0
Enabled=0
[pcbnew/Layer.In9.Cu]
Name=In9.Cu
Type=0
Enabled=0
[pcbnew/Layer.In10.Cu]
Name=In10.Cu
Type=0
Enabled=0
[pcbnew/Layer.In11.Cu]
Name=In11.Cu
Type=0
Enabled=0
[pcbnew/Layer.In12.Cu]
Name=In12.Cu
Type=0
Enabled=0
[pcbnew/Layer.In13.Cu]
Name=In13.Cu
Type=0
Enabled=0
[pcbnew/Layer.In14.Cu]
Name=In14.Cu
Type=0
Enabled=0
[pcbnew/Layer.In15.Cu]
Name=In15.Cu
Type=0
Enabled=0
[pcbnew/Layer.In16.Cu]
Name=In16.Cu
Type=0
Enabled=0
[pcbnew/Layer.In17.Cu]
Name=In17.Cu
Type=0
Enabled=0
[pcbnew/Layer.In18.Cu]
Name=In18.Cu
Type=0
Enabled=0
[pcbnew/Layer.In19.Cu]
Name=In19.Cu
Type=0
Enabled=0
[pcbnew/Layer.In20.Cu]
Name=In20.Cu
Type=0
Enabled=0
[pcbnew/Layer.In21.Cu]
Name=In21.Cu
Type=0
Enabled=0
[pcbnew/Layer.In22.Cu]
Name=In22.Cu
Type=0
Enabled=0
[pcbnew/Layer.In23.Cu]
Name=In23.Cu
Type=0
Enabled=0
[pcbnew/Layer.In24.Cu]
Name=In24.Cu
Type=0
Enabled=0
[pcbnew/Layer.In25.Cu]
Name=In25.Cu
Type=0
Enabled=0
[pcbnew/Layer.In26.Cu]
Name=In26.Cu
Type=0
Enabled=0
[pcbnew/Layer.In27.Cu]
Name=In27.Cu
Type=0
Enabled=0
[pcbnew/Layer.In28.Cu]
Name=In28.Cu
Type=0
Enabled=0
[pcbnew/Layer.In29.Cu]
Name=In29.Cu
Type=0
Enabled=0
[pcbnew/Layer.In30.Cu]
Name=In30.Cu
Type=0
Enabled=0
[pcbnew/Layer.B.Cu]
Name=B.Cu
Type=0
Enabled=1
[pcbnew/Layer.B.Adhes]
Enabled=1
[pcbnew/Layer.F.Adhes]
Enabled=1
[pcbnew/Layer.B.Paste]
Enabled=1
[pcbnew/Layer.F.Paste]
Enabled=1
[pcbnew/Layer.B.SilkS]
Enabled=1
[pcbnew/Layer.F.SilkS]
Enabled=1
[pcbnew/Layer.B.Mask]
Enabled=1
[pcbnew/Layer.F.Mask]
Enabled=1
[pcbnew/Layer.Dwgs.User]
Enabled=1
[pcbnew/Layer.Cmts.User]
Enabled=1
[pcbnew/Layer.Eco1.User]
Enabled=1
[pcbnew/Layer.Eco2.User]
Enabled=1
[pcbnew/Layer.Edge.Cuts]
Enabled=1
[pcbnew/Layer.Margin]
Enabled=1
[pcbnew/Layer.B.CrtYd]
Enabled=1
[pcbnew/Layer.F.CrtYd]
Enabled=1
[pcbnew/Layer.B.Fab]
Enabled=1
[pcbnew/Layer.F.Fab]
Enabled=1
[pcbnew/Layer.Rescue]
Enabled=0
[pcbnew/Netclasses]
[pcbnew/Netclasses/Default]
Name=Default
Clearance=0.2
TrackWidth=0.254
ViaDiameter=0.8128
ViaDrill=0.4064
uViaDiameter=0.3048
uViaDrill=0.1016
dPairWidth=0.2032
dPairGap=0.254
dPairViaGap=0.25
[pcbnew/Netclasses/1]
Name=power1
Clearance=0.254
TrackWidth=1.27
ViaDiameter=1.27
ViaDrill=0.7112
uViaDiameter=0.3048
uViaDrill=0.1016
dPairWidth=0.2032
dPairGap=0.254
dPairViaGap=0.25
[pcbnew/Netclasses/2]
Name=signal
Clearance=0.2032
TrackWidth=0.254
ViaDiameter=0.8128
ViaDrill=0.4064
uViaDiameter=0.3048
uViaDrill=0.1016
dPairWidth=0.2032
dPairGap=0.254
dPairViaGap=0.25

1119
hardware/interface-osi/unikbd-osi.sch Normal file
View File

File diff suppressed because it is too large Load Diff

1593
hardware/keyboard-classic/Aligner-cherry/aligner-cherry.kicad_pcb Normal file
View File

File diff suppressed because it is too large Load Diff

34
hardware/keyboard-classic/Aligner-cherry/aligner-cherry.pro Normal file
View File

@ -0,0 +1,34 @@
update=05/04/2019 20:44:53
version=1
last_client=kicad
[general]
version=1
RootSch=
BoardNm=
[pcbnew]
version=1
LastNetListRead=
UseCmpFile=1
PadDrill=0.600000000000
PadDrillOvalY=0.600000000000
PadSizeH=1.500000000000
PadSizeV=1.500000000000
PcbTextSizeV=1.500000000000
PcbTextSizeH=1.500000000000
PcbTextThickness=0.300000000000
ModuleTextSizeV=1.000000000000
ModuleTextSizeH=1.000000000000
ModuleTextSizeThickness=0.150000000000
SolderMaskClearance=0.000000000000
SolderMaskMinWidth=0.000000000000
DrawSegmentWidth=0.200000000000
BoardOutlineThickness=0.100000000000
ModuleOutlineThickness=0.150000000000
CopperEdgeClearance=0.000000000000
[cvpcb]
version=1
NetIExt=net
[eeschema]
version=1
LibDir=
[eeschema/libraries]

1628
hardware/keyboard-classic/Aligner-futaba/aligner-futaba.kicad_pcb Normal file
View File

File diff suppressed because it is too large Load Diff

34
hardware/keyboard-classic/Aligner-futaba/aligner-futaba.pro Normal file
View File

@ -0,0 +1,34 @@
update=05/04/2019 20:44:53
version=1
last_client=kicad
[general]
version=1
RootSch=
BoardNm=
[pcbnew]
version=1
LastNetListRead=
UseCmpFile=1
PadDrill=0.600000000000
PadDrillOvalY=0.600000000000
PadSizeH=1.500000000000
PadSizeV=1.500000000000
PcbTextSizeV=1.500000000000
PcbTextSizeH=1.500000000000
PcbTextThickness=0.300000000000
ModuleTextSizeV=1.000000000000
ModuleTextSizeH=1.000000000000
ModuleTextSizeThickness=0.150000000000
SolderMaskClearance=0.000000000000
SolderMaskMinWidth=0.000000000000
DrawSegmentWidth=0.200000000000
BoardOutlineThickness=0.100000000000
ModuleOutlineThickness=0.150000000000
CopperEdgeClearance=0.000000000000
[cvpcb]
version=1
NetIExt=net
[eeschema]
version=1
LibDir=
[eeschema/libraries]

177
hardware/keyboard-classic/Cutout-apple/apple_outline.kicad_pcb Normal file
View File

@ -0,0 +1,177 @@
(kicad_pcb (version 20171130) (host pcbnew "(5.1.4-0-10_14)")
(general
(thickness 1.6)
(drawings 35)
(tracks 0)
(zones 0)
(modules 0)
(nets 1)
)
(page B)
(title_block
(title "Universal Retro Keyboard")
(date 2019-08-25)
(rev 1.0)
(company OSIWeb.org)
(comment 1 "Key matrix w/ LED")
)
(layers
(0 F.Cu signal)
(31 B.Cu signal)
(32 B.Adhes user)
(33 F.Adhes user)
(34 B.Paste user)
(35 F.Paste user)
(36 B.SilkS user)
(37 F.SilkS user)
(38 B.Mask user)
(39 F.Mask user)
(40 Dwgs.User user)
(41 Cmts.User user)
(42 Eco1.User user)
(43 Eco2.User user)
(44 Edge.Cuts user)
(45 Margin user)
(46 B.CrtYd user)
(47 F.CrtYd user)
(48 B.Fab user)
(49 F.Fab user)
)
(setup
(last_trace_width 0.254)
(user_trace_width 0.254)
(user_trace_width 0.508)
(user_trace_width 1.27)
(trace_clearance 0.2)
(zone_clearance 0.508)
(zone_45_only no)
(trace_min 0.2)
(via_size 0.8128)
(via_drill 0.4064)
(via_min_size 0.4)
(via_min_drill 0.3)
(user_via 1.27 0.7112)
(uvia_size 0.3048)
(uvia_drill 0.1016)
(uvias_allowed no)
(uvia_min_size 0.2)
(uvia_min_drill 0.1)
(edge_width 0.1)
(segment_width 0.2)
(pcb_text_width 0.3)
(pcb_text_size 1.5 1.5)
(mod_edge_width 0.15)
(mod_text_size 1 1)
(mod_text_width 0.15)
(pad_size 3.9878 3.9878)
(pad_drill 3.9878)
(pad_to_mask_clearance 0)
(aux_axis_origin 61.4172 179.1081)
(visible_elements 7FFFEFFF)
(pcbplotparams
(layerselection 0x010fc_ffffffff)
(usegerberextensions false)
(usegerberattributes false)
(usegerberadvancedattributes false)
(creategerberjobfile false)
(excludeedgelayer true)
(linewidth 0.100000)
(plotframeref false)
(viasonmask false)
(mode 1)
(useauxorigin false)
(hpglpennumber 1)
(hpglpenspeed 20)
(hpglpendiameter 15.000000)
(psnegative false)
(psa4output false)
(plotreference true)
(plotvalue true)
(plotinvisibletext false)
(padsonsilk false)
(subtractmaskfromsilk false)
(outputformat 1)
(mirror false)
(drillshape 1)
(scaleselection 1)
(outputdirectory ""))
)
(net 0 "")
(net_class Default "This is the default net class."
(clearance 0.2)
(trace_width 0.254)
(via_dia 0.8128)
(via_drill 0.4064)
(uvia_dia 0.3048)
(uvia_drill 0.1016)
(diff_pair_width 0.2032)
(diff_pair_gap 0.254)
)
(net_class power1 ""
(clearance 0.254)
(trace_width 1.27)
(via_dia 1.27)
(via_drill 0.7112)
(uvia_dia 0.3048)
(uvia_drill 0.1016)
(diff_pair_width 0.2032)
(diff_pair_gap 0.254)
)
(net_class signal ""
(clearance 0.2032)
(trace_width 0.254)
(via_dia 0.8128)
(via_drill 0.4064)
(uvia_dia 0.3048)
(uvia_drill 0.1016)
(diff_pair_width 0.2032)
(diff_pair_gap 0.254)
)
(gr_line (start 78.359 175.133) (end 96.647 175.133) (layer B.Fab) (width 0.15) (tstamp 5D9294FB))
(gr_line (start 96.647 156.083) (end 96.647 175.133) (layer B.Fab) (width 0.15))
(gr_line (start 325.374 118.745) (end 320.548 118.745) (layer B.Fab) (width 0.15) (tstamp 5D92929E))
(gr_line (start 320.548 137.033) (end 320.548 156.083) (layer B.Fab) (width 0.15))
(gr_line (start 320.548 118.745) (end 320.548 137.033) (layer B.Fab) (width 0.15))
(gr_line (start 325.374 80.645) (end 325.374 118.745) (layer B.Fab) (width 0.15))
(gr_circle (center 143.51 78.74) (end 145.0975 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D91233E))
(gr_circle (center 290.83 78.74) (end 292.4175 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123A8))
(gr_circle (center 284.607 171.45) (end 286.1945 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D9122A9))
(gr_circle (center 107.7595 171.45) (end 109.347 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D9122A9))
(gr_circle (center 300.7106 78.74) (end 302.2981 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D912365))
(gr_circle (center 348.9706 78.74) (end 350.5581 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D912368))
(gr_circle (center 217.17 78.74) (end 218.7575 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123AE))
(gr_circle (center 364.49 78.74) (end 366.0775 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123AB))
(gr_circle (center 363.22 171.45) (end 364.8075 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D911836))
(gr_circle (center 71.12 171.45) (end 72.7075 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D911836))
(gr_circle (center 69.85 78.74) (end 71.4375 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123B1))
(gr_line (start 78.486 99.695) (end 78.486 80.645) (layer B.Fab) (width 0.15))
(gr_line (start 68.834 99.695) (end 78.486 99.695) (layer B.Fab) (width 0.15))
(gr_line (start 68.834 117.983) (end 68.834 99.695) (layer B.Fab) (width 0.15))
(gr_line (start 73.406 117.983) (end 68.834 117.983) (layer B.Fab) (width 0.15))
(gr_line (start 73.406 137.033) (end 73.406 117.983) (layer B.Fab) (width 0.15))
(gr_line (start 78.359 137.033) (end 73.533 137.033) (layer B.Fab) (width 0.15))
(gr_line (start 78.359 175.133) (end 78.359 137.033) (layer B.Fab) (width 0.15))
(gr_line (start 121.158 156.083) (end 96.647 156.083) (layer B.Fab) (width 0.15))
(gr_line (start 121.158 175.133) (end 121.158 156.083) (layer B.Fab) (width 0.15))
(gr_line (start 272.923 175.133) (end 121.158 175.133) (layer B.Fab) (width 0.15) (tstamp 5D90C768))
(gr_line (start 272.923 156.083) (end 272.923 175.133) (layer B.Fab) (width 0.15))
(gr_line (start 320.548 156.083) (end 272.923 156.083) (layer B.Fab) (width 0.15))
(gr_line (start 78.486 80.645) (end 325.374 80.645) (layer B.Fab) (width 0.15) (tstamp 5D90C80E))
(gr_line (start 64.77 177.8) (end 369.57 177.8) (layer Edge.Cuts) (width 0.1) (tstamp 5D911490))
(gr_line (start 64.77 73.914) (end 64.77 177.8) (layer Edge.Cuts) (width 0.1))
(gr_line (start 369.57 73.914) (end 64.77 73.914) (layer Edge.Cuts) (width 0.1) (tstamp 5D91148D))
(gr_line (start 369.57 177.8) (end 369.57 73.914) (layer Edge.Cuts) (width 0.1) (tstamp 5D91148A))
(gr_text "Distances:\nVertical: 0.75 inch\nHorizontal (1x - 1x): 0.75 inch\nHorizontal (1x - 1.5x): 0.939 inch\nHorizontal (Row 1 left key -> Row 2 left key): -0.379 inch\nHorizontal (Row 2 left key -> Row 3 left key): 0.187 inch\nHorizontal (Row 3 left key -> Row 4 left key): 0.186 inch\nHorizontal (Row 4 left key -> space bar): 4.310 inch" (at 38.4175 240.0681) (layer Cmts.User)
(effects (font (size 2.54 2.54) (thickness 0.3048)) (justify left))
)
)

33
hardware/keyboard-classic/Cutout-apple/apple_outline.pro Normal file
View File

@ -0,0 +1,33 @@
update=22/05/2015 07:44:53
version=1
last_client=kicad
[general]
version=1
RootSch=
BoardNm=
[pcbnew]
version=1
LastNetListRead=
UseCmpFile=1
PadDrill=0.600000000000
PadDrillOvalY=0.600000000000
PadSizeH=1.500000000000
PadSizeV=1.500000000000
PcbTextSizeV=1.500000000000
PcbTextSizeH=1.500000000000
PcbTextThickness=0.300000000000
ModuleTextSizeV=1.000000000000
ModuleTextSizeH=1.000000000000
ModuleTextSizeThickness=0.150000000000
SolderMaskClearance=0.000000000000
SolderMaskMinWidth=0.000000000000
DrawSegmentWidth=0.200000000000
BoardOutlineThickness=0.100000000000
ModuleOutlineThickness=0.150000000000
[cvpcb]
version=1
NetIExt=net
[eeschema]
version=1
LibDir=
[eeschema/libraries]

174
hardware/keyboard-classic/Cutout-classic/ascii_cutout.kicad_pcb Normal file
View File

@ -0,0 +1,174 @@
(kicad_pcb (version 20171130) (host pcbnew "(5.1.4-0-10_14)")
(general
(thickness 1.6)
(drawings 32)
(tracks 0)
(zones 0)
(modules 0)
(nets 1)
)
(page B)
(title_block
(title "Universal Retro Keyboard")
(date 2019-08-25)
(rev 1.0)
(company OSIWeb.org)
(comment 1 "Key matrix w/ LED")
)
(layers
(0 F.Cu signal)
(31 B.Cu signal)
(32 B.Adhes user)
(33 F.Adhes user)
(34 B.Paste user)
(35 F.Paste user)
(36 B.SilkS user)
(37 F.SilkS user)
(38 B.Mask user)
(39 F.Mask user)
(40 Dwgs.User user)
(41 Cmts.User user)
(42 Eco1.User user)
(43 Eco2.User user)
(44 Edge.Cuts user)
(45 Margin user)
(46 B.CrtYd user)
(47 F.CrtYd user)
(48 B.Fab user)
(49 F.Fab user)
)
(setup
(last_trace_width 0.254)
(user_trace_width 0.254)
(user_trace_width 0.508)
(user_trace_width 1.27)
(trace_clearance 0.2)
(zone_clearance 0.508)
(zone_45_only no)
(trace_min 0.2)
(via_size 0.8128)
(via_drill 0.4064)
(via_min_size 0.4)
(via_min_drill 0.3)
(user_via 1.27 0.7112)
(uvia_size 0.3048)
(uvia_drill 0.1016)
(uvias_allowed no)
(uvia_min_size 0.2)
(uvia_min_drill 0.1)
(edge_width 0.1)
(segment_width 0.2)
(pcb_text_width 0.3)
(pcb_text_size 1.5 1.5)
(mod_edge_width 0.15)
(mod_text_size 1 1)
(mod_text_width 0.15)
(pad_size 3.9878 3.9878)
(pad_drill 3.9878)
(pad_to_mask_clearance 0)
(aux_axis_origin 61.4172 179.1081)
(visible_elements 7FFFEFFF)
(pcbplotparams
(layerselection 0x010fc_ffffffff)
(usegerberextensions false)
(usegerberattributes false)
(usegerberadvancedattributes false)
(creategerberjobfile false)
(excludeedgelayer true)
(linewidth 0.100000)
(plotframeref false)
(viasonmask false)
(mode 1)
(useauxorigin false)
(hpglpennumber 1)
(hpglpenspeed 20)
(hpglpendiameter 15.000000)
(psnegative false)
(psa4output false)
(plotreference true)
(plotvalue true)
(plotinvisibletext false)
(padsonsilk false)
(subtractmaskfromsilk false)
(outputformat 1)
(mirror false)
(drillshape 1)
(scaleselection 1)
(outputdirectory ""))
)
(net 0 "")
(net_class Default "This is the default net class."
(clearance 0.2)
(trace_width 0.254)
(via_dia 0.8128)
(via_drill 0.4064)
(uvia_dia 0.3048)
(uvia_drill 0.1016)
(diff_pair_width 0.2032)
(diff_pair_gap 0.254)
)
(net_class power1 ""
(clearance 0.254)
(trace_width 1.27)
(via_dia 1.27)
(via_drill 0.7112)
(uvia_dia 0.3048)
(uvia_drill 0.1016)
(diff_pair_width 0.2032)
(diff_pair_gap 0.254)
)
(net_class signal ""
(clearance 0.2032)
(trace_width 0.254)
(via_dia 0.8128)
(via_drill 0.4064)
(uvia_dia 0.3048)
(uvia_drill 0.1016)
(diff_pair_width 0.2032)
(diff_pair_gap 0.254)
)
(gr_circle (center 143.51 78.74) (end 145.0975 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D91233E))
(gr_circle (center 290.83 78.74) (end 292.4175 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123A8))
(gr_circle (center 284.607 171.45) (end 286.1945 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D9122A9))
(gr_circle (center 107.7595 171.45) (end 109.347 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D9122A9))
(gr_circle (center 300.7106 78.74) (end 302.2981 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D912365))
(gr_circle (center 348.9706 78.74) (end 350.5581 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D912368))
(gr_circle (center 217.17 78.74) (end 218.7575 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123AE))
(gr_circle (center 364.49 78.74) (end 366.0775 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123AB))
(gr_circle (center 363.22 171.45) (end 364.8075 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D911836))
(gr_circle (center 71.12 171.45) (end 72.7075 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D911836))
(gr_circle (center 69.85 78.74) (end 71.4375 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123B1))
(gr_line (start 78.486 99.695) (end 78.486 80.645) (layer Edge.Cuts) (width 0.15))
(gr_line (start 68.834 99.695) (end 78.486 99.695) (layer Edge.Cuts) (width 0.15))
(gr_line (start 68.834 117.983) (end 68.834 99.695) (layer Edge.Cuts) (width 0.15))
(gr_line (start 73.406 117.983) (end 68.834 117.983) (layer Edge.Cuts) (width 0.15))
(gr_line (start 73.406 137.033) (end 73.406 117.983) (layer Edge.Cuts) (width 0.15))
(gr_line (start 78.359 137.033) (end 73.533 137.033) (layer Edge.Cuts) (width 0.15))
(gr_line (start 78.359 156.083) (end 78.359 137.033) (layer Edge.Cuts) (width 0.15))
(gr_line (start 121.158 156.083) (end 78.359 156.083) (layer Edge.Cuts) (width 0.15))
(gr_line (start 121.158 175.133) (end 121.158 156.083) (layer Edge.Cuts) (width 0.15))
(gr_line (start 272.923 175.133) (end 121.158 175.133) (layer Edge.Cuts) (width 0.15) (tstamp 5D90C768))
(gr_line (start 272.923 156.083) (end 272.923 175.133) (layer Edge.Cuts) (width 0.15))
(gr_line (start 358.648 156.083) (end 272.923 156.083) (layer Edge.Cuts) (width 0.15))
(gr_line (start 358.648 117.983) (end 358.648 156.083) (layer Edge.Cuts) (width 0.15))
(gr_line (start 363.347 117.983) (end 358.648 117.983) (layer Edge.Cuts) (width 0.15) (tstamp 5D90C7F7))
(gr_line (start 363.347 80.645) (end 363.347 117.983) (layer Edge.Cuts) (width 0.15))
(gr_line (start 78.486 80.645) (end 363.347 80.645) (layer Edge.Cuts) (width 0.15) (tstamp 5D90C80E))
(gr_line (start 64.77 177.8) (end 369.57 177.8) (layer Edge.Cuts) (width 0.1) (tstamp 5D911490))
(gr_line (start 64.77 73.914) (end 64.77 177.8) (layer Edge.Cuts) (width 0.1))
(gr_line (start 369.57 73.914) (end 64.77 73.914) (layer Edge.Cuts) (width 0.1) (tstamp 5D91148D))
(gr_line (start 369.57 177.8) (end 369.57 73.914) (layer Edge.Cuts) (width 0.1) (tstamp 5D91148A))
(gr_text "Distances:\nVertical: 0.75 inch\nHorizontal (1x - 1x): 0.75 inch\nHorizontal (1x - 1.5x): 0.939 inch\nHorizontal (Row 1 left key -> Row 2 left key): -0.379 inch\nHorizontal (Row 2 left key -> Row 3 left key): 0.187 inch\nHorizontal (Row 3 left key -> Row 4 left key): 0.186 inch\nHorizontal (Row 4 left key -> space bar): 4.310 inch" (at 38.4175 240.0681) (layer Cmts.User)
(effects (font (size 2.54 2.54) (thickness 0.3048)) (justify left))
)
)

33
hardware/keyboard-classic/Cutout-classic/ascii_cutout.pro Normal file
View File

@ -0,0 +1,33 @@
update=22/05/2015 07:44:53
version=1
last_client=kicad
[general]
version=1
RootSch=
BoardNm=
[pcbnew]
version=1
LastNetListRead=
UseCmpFile=1
PadDrill=0.600000000000
PadDrillOvalY=0.600000000000
PadSizeH=1.500000000000
PadSizeV=1.500000000000
PcbTextSizeV=1.500000000000
PcbTextSizeH=1.500000000000
PcbTextThickness=0.300000000000
ModuleTextSizeV=1.000000000000
ModuleTextSizeH=1.000000000000
ModuleTextSizeThickness=0.150000000000
SolderMaskClearance=0.000000000000
SolderMaskMinWidth=0.000000000000
DrawSegmentWidth=0.200000000000
BoardOutlineThickness=0.100000000000
ModuleOutlineThickness=0.150000000000
[cvpcb]
version=1
NetIExt=net
[eeschema]
version=1
LibDir=
[eeschema/libraries]

176
hardware/keyboard-classic/Cutout-osi/osi_outline.kicad_pcb Normal file
View File

@ -0,0 +1,176 @@
(kicad_pcb (version 20171130) (host pcbnew "(5.1.4-0-10_14)")
(general
(thickness 1.6)
(drawings 34)
(tracks 0)
(zones 0)
(modules 0)
(nets 1)
)
(page B)
(title_block
(title "Universal Retro Keyboard")
(date 2019-08-25)
(rev 1.0)
(company OSIWeb.org)
(comment 1 "Key matrix w/ LED")
)
(layers
(0 F.Cu signal)
(31 B.Cu signal)
(32 B.Adhes user)
(33 F.Adhes user)
(34 B.Paste user)
(35 F.Paste user)
(36 B.SilkS user)
(37 F.SilkS user)
(38 B.Mask user)
(39 F.Mask user)
(40 Dwgs.User user)
(41 Cmts.User user)
(42 Eco1.User user)
(43 Eco2.User user)
(44 Edge.Cuts user)
(45 Margin user)
(46 B.CrtYd user)
(47 F.CrtYd user)
(48 B.Fab user)
(49 F.Fab user)
)
(setup
(last_trace_width 0.254)
(user_trace_width 0.254)
(user_trace_width 0.508)
(user_trace_width 1.27)
(trace_clearance 0.2)
(zone_clearance 0.508)
(zone_45_only no)
(trace_min 0.2)
(via_size 0.8128)
(via_drill 0.4064)
(via_min_size 0.4)
(via_min_drill 0.3)
(user_via 1.27 0.7112)
(uvia_size 0.3048)
(uvia_drill 0.1016)
(uvias_allowed no)
(uvia_min_size 0.2)
(uvia_min_drill 0.1)
(edge_width 0.1)
(segment_width 0.2)
(pcb_text_width 0.3)
(pcb_text_size 1.5 1.5)
(mod_edge_width 0.15)
(mod_text_size 1 1)
(mod_text_width 0.15)
(pad_size 3.9878 3.9878)
(pad_drill 3.9878)
(pad_to_mask_clearance 0)
(aux_axis_origin 61.4172 179.1081)
(visible_elements 7FFFEFFF)
(pcbplotparams
(layerselection 0x010fc_ffffffff)
(usegerberextensions false)
(usegerberattributes false)
(usegerberadvancedattributes false)
(creategerberjobfile false)
(excludeedgelayer true)
(linewidth 0.100000)
(plotframeref false)
(viasonmask false)
(mode 1)
(useauxorigin false)
(hpglpennumber 1)
(hpglpenspeed 20)
(hpglpendiameter 15.000000)
(psnegative false)
(psa4output false)
(plotreference true)
(plotvalue true)
(plotinvisibletext false)
(padsonsilk false)
(subtractmaskfromsilk false)
(outputformat 1)
(mirror false)
(drillshape 1)
(scaleselection 1)
(outputdirectory ""))
)
(net 0 "")
(net_class Default "This is the default net class."
(clearance 0.2)
(trace_width 0.254)
(via_dia 0.8128)
(via_drill 0.4064)
(uvia_dia 0.3048)
(uvia_drill 0.1016)
(diff_pair_width 0.2032)
(diff_pair_gap 0.254)
)
(net_class power1 ""
(clearance 0.254)
(trace_width 1.27)
(via_dia 1.27)
(via_drill 0.7112)
(uvia_dia 0.3048)
(uvia_drill 0.1016)
(diff_pair_width 0.2032)
(diff_pair_gap 0.254)
)
(net_class signal ""
(clearance 0.2032)
(trace_width 0.254)
(via_dia 0.8128)
(via_drill 0.4064)
(uvia_dia 0.3048)
(uvia_drill 0.1016)
(diff_pair_width 0.2032)
(diff_pair_gap 0.254)
)
(gr_line (start 320.548 137.033) (end 320.548 156.083) (layer B.Fab) (width 0.15))
(gr_line (start 339.598 137.033) (end 320.548 137.033) (layer B.Fab) (width 0.15))
(gr_line (start 339.598 118.745) (end 339.598 137.033) (layer B.Fab) (width 0.15))
(gr_line (start 325.374 118.745) (end 339.598 118.745) (layer B.Fab) (width 0.15))
(gr_line (start 325.374 80.645) (end 325.374 118.745) (layer B.Fab) (width 0.15))
(gr_circle (center 143.51 78.74) (end 145.0975 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D91233E))
(gr_circle (center 290.83 78.74) (end 292.4175 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123A8))
(gr_circle (center 284.607 171.45) (end 286.1945 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D9122A9))
(gr_circle (center 107.7595 171.45) (end 109.347 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D9122A9))
(gr_circle (center 300.7106 78.74) (end 302.2981 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D912365))
(gr_circle (center 348.9706 78.74) (end 350.5581 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D912368))
(gr_circle (center 217.17 78.74) (end 218.7575 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123AE))
(gr_circle (center 364.49 78.74) (end 366.0775 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123AB))
(gr_circle (center 363.22 171.45) (end 364.8075 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D911836))
(gr_circle (center 71.12 171.45) (end 72.7075 171.45) (layer Edge.Cuts) (width 0.1) (tstamp 5D911836))
(gr_circle (center 69.85 78.74) (end 71.4375 78.74) (layer Edge.Cuts) (width 0.1) (tstamp 5D9123B1))
(gr_line (start 78.486 99.695) (end 78.486 80.645) (layer B.Fab) (width 0.15))
(gr_line (start 68.834 99.695) (end 78.486 99.695) (layer B.Fab) (width 0.15))
(gr_line (start 68.834 117.983) (end 68.834 99.695) (layer B.Fab) (width 0.15))
(gr_line (start 73.406 117.983) (end 68.834 117.983) (layer B.Fab) (width 0.15))
(gr_line (start 73.406 137.033) (end 73.406 117.983) (layer B.Fab) (width 0.15))
(gr_line (start 78.359 137.033) (end 73.533 137.033) (layer B.Fab) (width 0.15))
(gr_line (start 78.359 156.083) (end 78.359 137.033) (layer B.Fab) (width 0.15))
(gr_line (start 121.158 156.083) (end 78.359 156.083) (layer B.Fab) (width 0.15))
(gr_line (start 121.158 175.133) (end 121.158 156.083) (layer B.Fab) (width 0.15))
(gr_line (start 272.923 175.133) (end 121.158 175.133) (layer B.Fab) (width 0.15) (tstamp 5D90C768))
(gr_line (start 272.923 156.083) (end 272.923 175.133) (layer B.Fab) (width 0.15))
(gr_line (start 320.548 156.083) (end 272.923 156.083) (layer B.Fab) (width 0.15))
(gr_line (start 78.486 80.645) (end 325.374 80.645) (layer B.Fab) (width 0.15) (tstamp 5D90C80E))
(gr_line (start 64.77 177.8) (end 369.57 177.8) (layer Edge.Cuts) (width 0.1) (tstamp 5D911490))
(gr_line (start 64.77 73.914) (end 64.77 177.8) (layer Edge.Cuts) (width 0.1))
(gr_line (start 369.57 73.914) (end 64.77 73.914) (layer Edge.Cuts) (width 0.1) (tstamp 5D91148D))
(gr_line (start 369.57 177.8) (end 369.57 73.914) (layer Edge.Cuts) (width 0.1) (tstamp 5D91148A))
(gr_text "Distances:\nVertical: 0.75 inch\nHorizontal (1x - 1x): 0.75 inch\nHorizontal (1x - 1.5x): 0.939 inch\nHorizontal (Row 1 left key -> Row 2 left key): -0.379 inch\nHorizontal (Row 2 left key -> Row 3 left key): 0.187 inch\nHorizontal (Row 3 left key -> Row 4 left key): 0.186 inch\nHorizontal (Row 4 left key -> space bar): 4.310 inch" (at 38.4175 240.0681) (layer Cmts.User)
(effects (font (size 2.54 2.54) (thickness 0.3048)) (justify left))
)
)

33
hardware/keyboard-classic/Cutout-osi/osi_outline.pro Normal file
View File

@ -0,0 +1,33 @@
update=22/05/2015 07:44:53
version=1
last_client=kicad
[general]
version=1
RootSch=
BoardNm=
[pcbnew]
version=1
LastNetListRead=
UseCmpFile=1
PadDrill=0.600000000000
PadDrillOvalY=0.600000000000
PadSizeH=1.500000000000
PadSizeV=1.500000000000
PcbTextSizeV=1.500000000000
PcbTextSizeH=1.500000000000
PcbTextThickness=0.300000000000
ModuleTextSizeV=1.000000000000
ModuleTextSizeH=1.000000000000
ModuleTextSizeThickness=0.150000000000
SolderMaskClearance=0.000000000000
SolderMaskMinWidth=0.000000000000
DrawSegmentWidth=0.200000000000
BoardOutlineThickness=0.100000000000
ModuleOutlineThickness=0.150000000000
[cvpcb]
version=1
NetIExt=net
[eeschema]
version=1
LibDir=
[eeschema/libraries]

6660
hardware/keyboard-classic/kbd-classic.kicad_pcb Normal file
View File

File diff suppressed because it is too large Load Diff

33
hardware/keyboard-classic/kbd-classic.pro Normal file
View File

@ -0,0 +1,33 @@
update=22/05/2015 07:44:53
version=1
last_client=kicad
[general]
version=1
RootSch=
BoardNm=
[pcbnew]
version=1
LastNetListRead=
UseCmpFile=1
PadDrill=0.600000000000
PadDrillOvalY=0.600000000000
PadSizeH=1.500000000000
PadSizeV=1.500000000000
PcbTextSizeV=1.500000000000
PcbTextSizeH=1.500000000000
PcbTextThickness=0.300000000000
ModuleTextSizeV=1.000000000000
ModuleTextSizeH=1.000000000000
ModuleTextSizeThickness=0.150000000000
SolderMaskClearance=0.000000000000
SolderMaskMinWidth=0.000000000000
DrawSegmentWidth=0.200000000000
BoardOutlineThickness=0.100000000000
ModuleOutlineThickness=0.150000000000
[cvpcb]
version=1
NetIExt=net
[eeschema]
version=1
LibDir=
[eeschema/libraries]

464
hardware/keyboard-classic/kbd-classic.sch Normal file
View File

@ -0,0 +1,464 @@
EESchema Schematic File Version 4
EELAYER 30 0
EELAYER END
$Descr USLetter 11000 8500
encoding utf-8
Sheet 1 3
Title "Universal Retro Keyboard"
Date "2019-08-25"
Rev "1.0"
Comp "OSIWeb.org"
Comment1 "Main sheet with connector"
Comment2 ""
Comment3 ""
Comment4 ""
$EndDescr
Text Label 2725 4300 2 50 ~ 0
Col0
Text Label 2725 4200 2 50 ~ 0
Col1
Text Label 2725 4100 2 50 ~ 0
Col2
Text Label 2725 4000 2 50 ~ 0
Col3
Text Label 2725 3900 2 50 ~ 0
Col4
Text Label 2725 3800 2 50 ~ 0
Col5
Text Label 2725 3700 2 50 ~ 0
Col6
Text Label 2725 3600 2 50 ~ 0
Col7
Text Label 2725 1800 2 50 ~ 0
Col0
Text Label 2725 1700 2 50 ~ 0
Col1
Text Label 2725 1600 2 50 ~ 0
Col2
Text Label 2725 1500 2 50 ~ 0
Col3
Text Label 2725 1400 2 50 ~ 0
Col4
Text Label 2725 1300 2 50 ~ 0
Col5
Text Label 2725 1200 2 50 ~ 0
Col6
Text Label 2725 4800 2 50 ~ 0
Row0
Text Label 2725 4700 2 50 ~ 0
Row1
Text Label 2725 4600 2 50 ~ 0
Row2
Text Label 2725 4500 2 50 ~ 0
Row3
Text Label 2725 2350 2 50 ~ 0
Row4
Text Label 2725 2250 2 50 ~ 0
Row5
Text Label 2725 2150 2 50 ~ 0
Row6
Text Label 2725 2050 2 50 ~ 0
Row7
$Sheet
S 775 900 1700 1900
U 5BC3EA0A
F0 "keys2" 60
F1 "keys2.sch" 60
F2 "Col0" I R 2475 1800 50
F3 "Col1" I R 2475 1700 50
F4 "Col2" I R 2475 1600 50
F5 "Col3" I R 2475 1500 50
F6 "Col4" I R 2475 1400 50
F7 "Col5" I R 2475 1300 50
F8 "Col6" I R 2475 1200 50
F9 "Col7" I R 2475 1100 50
F10 "Row4" I R 2475 2350 50
F11 "Row5" I R 2475 2250 50
F12 "Row6" I R 2475 2150 50
F13 "Row7" I R 2475 2050 50
$EndSheet
$Sheet
S 775 3400 1700 1900
U 5BC3E99D
F0 "keys1" 60
F1 "keys1.sch" 60
F2 "Col0" I R 2475 4300 50
F3 "Col1" I R 2475 4200 50
F4 "Col2" I R 2475 4100 50
F5 "Col3" I R 2475 4000 50
F6 "Col4" I R 2475 3900 50
F7 "Col5" I R 2475 3800 50
F8 "Col6" I R 2475 3700 50
F9 "Col7" I R 2475 3600 50
F10 "Row0" I R 2475 4800 50
F11 "Row1" I R 2475 4700 50
F12 "Row2" I R 2475 4600 50
F13 "Row3" I R 2475 4500 50
$EndSheet
Text Notes 580 7070 0 79 ~ 0
For OSI keyboards:\n“@“ (AT symbol) maps to “Shift Lock”, R0 C0\n“[“ (left bracket) maps to “Rub Out”, R6 C2\n“\” maps to “Repeat”, R0 C7\n“Rubout” maps to “Break”, \nDNP: “]” (right bracket), “^”, “Here is”, “Break”, “Repeat”, “Clear”
Text Notes 600 7905 0 79 ~ 0
For Apple II keyboards:\n"@" (AT symbol) maps to "Left arrow"\n"\" maps to "Right Arrow"\n"[" (left bracket) maps to "Reset"\n\nDNP: "]" (right bracket), "^", "Here is", "Rub", "Break", "Repeat", "Clear"
$Comp
L Switch:SW_Push_LED SW9
U 1 1 5DF7D21E
P 9250 2875
F 0 "SW9" V 9170 3115 50 0000 C CNN
F 1 "Caps_Lock" V 9000 2875 50 0000 C CNN
F 2 "unikbd:Key_MX_LED" H 9250 3175 50 0001 C CNN
F 3 "~" H 9250 3175 50 0001 C CNN
1 9250 2875
0 1 -1 0
$EndComp
$Comp
L Switch:SW_Push_LED SW32
U 1 1 5DF7DA75
P 9425 1850
F 0 "SW32" H 9150 2025 50 0000 C CNN
F 1 "@ (OSI shift lock)" H 9300 2125 50 0000 C CNN
F 2 "unikbd:Key_MX_LED" H 9425 2150 50 0001 C CNN
F 3 "~" H 9425 2150 50 0001 C CNN
1 9425 1850
-1 0 0 -1
$EndComp
NoConn ~ 7900 2850
NoConn ~ 7900 2950
NoConn ~ 7900 3050
NoConn ~ 7900 3150
$Comp
L Switch:SW_Push_LED SW61
U 1 1 5DF0C543
P 8730 1450
F 0 "SW61" H 8600 1660 50 0000 C CNN
F 1 "Power light" H 8760 1750 50 0000 C CNN
F 2 "unikbd:Key_MX_LED" H 8730 1750 50 0001 C CNN
F 3 "~" H 8730 1750 50 0001 C CNN
1 8730 1450
-1 0 0 -1
$EndComp
Wire Wire Line
8400 1450 8530 1450
Wire Wire Line
9000 1550 8400 1550
Wire Wire Line
9000 1450 9000 1550
Wire Wire Line
8930 1450 9000 1450
Wire Wire Line
8990 1350 8930 1350
Wire Wire Line
8990 1070 8990 1350
Wire Wire Line
8400 1070 8990 1070
Wire Wire Line
8400 1250 8400 1070
Wire Wire Line
8530 1350 8400 1350
NoConn ~ 8400 3150
NoConn ~ 8400 3050
NoConn ~ 8400 2950
NoConn ~ 8400 2850
NoConn ~ 8400 2750
NoConn ~ 8400 2650
$Comp
L Connector_Generic:Conn_02x20_Odd_Even J1
U 1 1 5D1E4169
P 8100 2150
F 0 "J1" H 8150 3267 50 0000 C CNN
F 1 "Controller" H 8150 3176 50 0000 C CNN
F 2 "Connector_PinHeader_2.54mm:PinHeader_2x20_P2.54mm_Vertical" H 8100 2150 50 0001 C CNN
F 3 "~" H 8100 2150 50 0001 C CNN
1 8100 2150
1 0 0 -1
$EndComp
Text Label 2725 1100 2 50 ~ 0
Col7
Text Label 7850 1250 2 50 ~ 0
Col7
Text Label 7850 1350 2 50 ~ 0
Col6
Text Label 7850 1550 2 50 ~ 0
Col4
Text Label 7850 1450 2 50 ~ 0
Col5
Text Label 7850 1750 2 50 ~ 0
Col2
Text Label 7850 1650 2 50 ~ 0
Col3
Text Label 7850 1850 2 50 ~ 0
Col1
Text Label 7850 1950 2 50 ~ 0
Col0
Text Label 7850 2050 2 50 ~ 0
Row7
Text Label 7850 2150 2 50 ~ 0
Row6
Text Label 7850 2250 2 50 ~ 0
Row5
Text Label 7850 2350 2 50 ~ 0
Row4
Text Label 7850 2450 2 50 ~ 0
Row3
Text Label 7850 2550 2 50 ~ 0
Row2
Text Label 7850 2650 2 50 ~ 0
Row1
Text Label 7850 2750 2 50 ~ 0
Row0
Entry Wire Line
2825 1800 2925 1700
Entry Wire Line
2825 1700 2925 1600
Entry Wire Line
2825 1600 2925 1500
Entry Wire Line
2825 1500 2925 1400
Entry Wire Line
2825 1400 2925 1300
Entry Wire Line
2825 1300 2925 1200
Entry Wire Line
2825 1200 2925 1100
Entry Wire Line
2825 1100 2925 1000
Entry Wire Line
2825 2350 2925 2250
Entry Wire Line
2825 2250 2925 2150
Entry Wire Line
2825 2150 2925 2050
Entry Wire Line
2825 2050 2925 1950
Entry Wire Line
2825 4300 2925 4200
Entry Wire Line
2825 4200 2925 4100
Entry Wire Line
2825 4100 2925 4000
Entry Wire Line
2825 4000 2925 3900
Entry Wire Line
2825 3900 2925 3800
Entry Wire Line
2825 3800 2925 3700
Entry Wire Line
2825 3700 2925 3600
Entry Wire Line
2825 3600 2925 3500
Entry Wire Line
2825 4800 2925 4700
Entry Wire Line
2825 4700 2925 4600
Entry Wire Line
2825 4600 2925 4500
Entry Wire Line
2825 4500 2925 4400
Entry Wire Line
7500 2750 7400 2650
Entry Wire Line
7500 2650 7400 2550
Entry Wire Line
7500 2550 7400 2450
Entry Wire Line
7500 2450 7400 2350
Entry Wire Line
7500 2350 7400 2250
Entry Wire Line
7500 2250 7400 2150
Entry Wire Line
7500 2150 7400 2050
Entry Wire Line
7500 2050 7400 1950
Entry Wire Line
7500 1950 7400 1850
Entry Wire Line
7500 1850 7400 1750
Entry Wire Line
7500 1750 7400 1650
Entry Wire Line
7500 1650 7400 1550
Entry Wire Line
7500 1550 7400 1450
Entry Wire Line
7500 1450 7400 1350
Entry Wire Line
7500 1350 7400 1250
Entry Wire Line
7500 1250 7400 1150
Wire Wire Line
7900 1250 7500 1250
Wire Wire Line
7500 1350 7900 1350
Wire Wire Line
7900 1450 7500 1450
Wire Wire Line
7900 1550 7500 1550
Wire Wire Line
7900 1650 7500 1650
Wire Wire Line
7500 1750 7900 1750
Wire Wire Line
7900 1850 7500 1850
Wire Wire Line
7500 1950 7900 1950
Wire Wire Line
7900 2050 7500 2050
Wire Wire Line
7500 2150 7900 2150
Wire Wire Line
7900 2250 7500 2250
Wire Wire Line
7500 2350 7900 2350
Wire Wire Line
7900 2450 7500 2450
Wire Wire Line
7500 2550 7900 2550
Wire Wire Line
7500 2650 7900 2650
Wire Wire Line
7500 2750 7900 2750
Wire Wire Line
2475 1100 2825 1100
Wire Wire Line
2825 1200 2475 1200
Wire Wire Line
2475 1300 2825 1300
Wire Wire Line
2825 1400 2475 1400
Wire Wire Line
2475 1500 2825 1500
Wire Wire Line
2825 1600 2475 1600
Wire Wire Line
2475 1700 2825 1700
Wire Wire Line
2825 1800 2475 1800
Wire Wire Line
2475 3600 2825 3600
Wire Wire Line
2825 3700 2475 3700
Wire Wire Line
2475 3800 2825 3800
Wire Wire Line
2825 3900 2475 3900
Wire Wire Line
2475 4000 2825 4000
Wire Wire Line
2825 4100 2475 4100
Wire Wire Line
2475 4200 2825 4200
Wire Wire Line
2825 4300 2475 4300
Wire Wire Line
2475 2050 2825 2050
Wire Wire Line
2825 2150 2475 2150
Wire Wire Line
2475 2250 2825 2250
Wire Wire Line
2825 2350 2475 2350
Wire Wire Line
2475 4500 2825 4500
Wire Wire Line
2825 4600 2475 4600
Wire Wire Line
2475 4700 2825 4700
Wire Wire Line
2825 4800 2475 4800
Wire Bus Line
2925 700 7400 700
Wire Wire Line
8400 2250 9250 2250
Wire Wire Line
9250 2250 9250 2675
Wire Wire Line
9250 3075 9100 3075
Wire Wire Line
9100 3075 9100 2350
Wire Wire Line
9100 2350 8400 2350
Entry Wire Line
10200 2670 10300 2570
Entry Wire Line
10200 3075 10300 2975
Wire Bus Line
10300 700 7400 700
Connection ~ 7400 700
Text Label 9850 2670 2 50 ~ 0
Row5
Text Label 9850 3075 2 50 ~ 0
Col2
$Comp
L Diode:1N4148 D?
U 1 1 5DFE048B
P 9550 2670
AR Path="/5BC3E99D/5DFE048B" Ref="D?" Part="1"
AR Path="/5BC3EA0A/5DFE048B" Ref="D?" Part="1"
AR Path="/5DFE048B" Ref="D10" Part="1"
F 0 "D10" H 9596 2591 50 0000 R CNN
F 1 "1N4148" H 9625 2770 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 9550 2495 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 9550 2670 50 0001 C CNN
1 9550 2670
-1 0 0 1
$EndComp
Wire Wire Line
10200 2670 9700 2670
Wire Wire Line
8400 2050 9700 2050
$Comp
L Switch:SW_Push SW?
U 1 1 5D6C3751
P 9900 2050
AR Path="/5BC3E99D/5D6C3751" Ref="SW?" Part="1"
AR Path="/5D6C3751" Ref="SW34" Part="1"
F 0 "SW34" H 9650 2100 50 0000 C CNN
F 1 "Rubout (OSI Break)" H 9770 2000 50 0000 C CNN
F 2 "unikbd:Key_MX" H 9900 2250 50 0001 C CNN
F 3 "" H 9900 2250 50 0001 C CNN
1 9900 2050
1 0 0 -1
$EndComp
Wire Wire Line
9225 1750 8400 1750
Wire Wire Line
9625 1750 9900 1750
Wire Wire Line
9900 1750 9900 1525
Wire Wire Line
9900 1525 9175 1525
Wire Wire Line
9175 1525 9175 1650
Wire Wire Line
9175 1650 8400 1650
Wire Wire Line
8400 1850 9225 1850
Wire Wire Line
9625 1850 9775 1850
Wire Wire Line
9775 1850 9775 1950
Wire Wire Line
9775 1950 8400 1950
Wire Wire Line
10100 2050 10150 2050
Wire Wire Line
10150 2050 10150 2150
Wire Wire Line
10150 2150 8400 2150
NoConn ~ 8400 2550
NoConn ~ 8400 2450
Text Notes 580 6180 0 79 ~ 0
For Classic ASCII keyboards:\n“@“ (AT symbol) is mapped to R7 C0\n“Rubout” is mapped to R1 C0\n“Power Button” is mapped to R0 C0\n
Wire Wire Line
9350 3075 10200 3075
Wire Wire Line
9400 2670 9350 2670
Wire Wire Line
9350 2670 9350 2675
Wire Bus Line
10300 700 10300 2975
Wire Bus Line
7400 700 7400 2650
Wire Bus Line
2925 700 2925 4700
$EndSCHEMATC

866
hardware/keyboard-classic/keys1.sch Normal file
View File

@ -0,0 +1,866 @@
EESchema Schematic File Version 4
EELAYER 30 0
EELAYER END
$Descr A4 11693 8268
encoding utf-8
Sheet 3 3
Title "Universal Retro Keyboard"
Date "2019-08-25"
Rev "1.0"
Comp "OSIWeb.org"
Comment1 "Key Matrix part 2"
Comment2 ""
Comment3 ""
Comment4 ""
$EndDescr
Text HLabel 1450 4500 0 60 Input ~ 0
Row1
Text HLabel 1450 5400 0 60 Input ~ 0
Row2
Text HLabel 1450 6300 0 60 Input ~ 0
Row3
Text HLabel 1450 3600 0 60 Input ~ 0
Row0
Text HLabel 1450 1100 0 60 Input ~ 0
Col7
Text HLabel 1450 1300 0 60 Input ~ 0
Col6
Text HLabel 1450 1500 0 60 Input ~ 0
Col5
Text HLabel 1450 1700 0 60 Input ~ 0
Col4
Text HLabel 1450 1900 0 60 Input ~ 0
Col3
Text HLabel 1450 2100 0 60 Input ~ 0
Col2
Text HLabel 1450 2300 0 60 Input ~ 0
Col1
Text HLabel 1450 2500 0 60 Input ~ 0
Col0
$Comp
L Switch:SW_Push SW35
U 1 1 5BC3FD26
P 3800 3200
F 0 "SW35" H 3800 3485 50 0000 C CNN
F 1 "R_Shift" H 3800 3394 50 0000 C CNN
F 2 "unikbd:Key_MX" H 3800 3400 50 0001 C CNN
F 3 "" H 3800 3400 50 0001 C CNN
1 3800 3200
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW39
U 1 1 5BC3FE57
P 4600 3200
F 0 "SW39" H 4600 3485 50 0000 C CNN
F 1 "L_Shift" H 4600 3394 50 0000 C CNN
F 2 "unikbd:Key_MX" H 4600 3400 50 0001 C CNN
F 3 "" H 4600 3400 50 0001 C CNN
1 4600 3200
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW49
U 1 1 5BC3FF69
P 7000 3200
F 0 "SW49" H 7000 3485 50 0000 C CNN
F 1 "ESC" H 7000 3394 50 0000 C CNN
F 2 "unikbd:Key_MX" H 7000 3400 50 0001 C CNN
F 3 "" H 7000 3400 50 0001 C CNN
1 7000 3200
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW57
U 1 1 5BC3FF70
P 8600 3200
F 0 "SW57" H 8600 3485 50 0000 C CNN
F 1 "Backslash" H 8600 3394 50 0000 C CNN
F 2 "unikbd:Key_MX" H 8600 3400 50 0001 C CNN
F 3 "" H 8600 3400 50 0001 C CNN
1 8600 3200
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW53
U 1 1 5BC3FF77
P 7800 3200
F 0 "SW53" H 7800 3485 50 0000 C CNN
F 1 "CTRL" H 7800 3394 50 0000 C CNN
F 2 "unikbd:Key_MX" H 7800 3400 50 0001 C CNN
F 3 "" H 7800 3400 50 0001 C CNN
1 7800 3200
1 0 0 -1
$EndComp
$Comp
L Diode:1N4148 D36
U 1 1 5BC6C862
P 4000 3450
F 0 "D36" V 4046 3371 50 0000 R CNN
F 1 "1N4148" V 3955 3371 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 4000 3275 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 4000 3450 50 0001 C CNN
1 4000 3450
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D40
U 1 1 5BC6CA8E
P 4800 3450
F 0 "D40" V 4846 3371 50 0000 R CNN
F 1 "1N4148" V 4755 3371 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 4800 3275 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 4800 3450 50 0001 C CNN
1 4800 3450
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D50
U 1 1 5BC6CB1B
P 7200 3450
F 0 "D50" V 7246 3371 50 0000 R CNN
F 1 "1N4148" V 7155 3371 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 7200 3275 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 7200 3450 50 0001 C CNN
1 7200 3450
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D54
U 1 1 5BC6CB46
P 8000 3450
F 0 "D54" V 8046 3371 50 0000 R CNN
F 1 "1N4148" V 7955 3371 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 8000 3275 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 8000 3450 50 0001 C CNN
1 8000 3450
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D58
U 1 1 5BC6CB6F
P 8800 3450
F 0 "D58" V 8846 3371 50 0000 R CNN
F 1 "1N4148" V 8755 3371 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 8800 3275 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 8800 3450 50 0001 C CNN
1 8800 3450
0 -1 -1 0
$EndComp
$Comp
L Switch:SW_Push SW36
U 1 1 5BC6CD5D
P 3800 4100
F 0 "SW36" H 3800 4385 50 0000 C CNN
F 1 "P" H 3800 4294 50 0000 C CNN
F 2 "unikbd:Key_MX" H 3800 4300 50 0001 C CNN
F 3 "" H 3800 4300 50 0001 C CNN
1 3800 4100
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW43
U 1 1 5BC6CD64
P 5400 4100
F 0 "SW43" H 5400 4385 50 0000 C CNN
F 1 "Fwd_Slash" H 5400 4294 50 0000 C CNN
F 2 "unikbd:Key_MX" H 5400 4300 50 0001 C CNN
F 3 "" H 5400 4300 50 0001 C CNN
1 5400 4100
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW40
U 1 1 5BC6CD6B
P 4600 4100
F 0 "SW40" H 4600 4385 50 0000 C CNN
F 1 "Semicolon" H 4600 4294 50 0000 C CNN
F 2 "unikbd:Key_MX" H 4600 4300 50 0001 C CNN
F 3 "" H 4600 4300 50 0001 C CNN
1 4600 4100
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW46
U 1 1 5BC6CD72
P 6200 4100
F 0 "SW46" H 6200 4385 50 0000 C CNN
F 1 "SPACE" H 6200 4294 50 0000 C CNN
F 2 "unikbd:Key_MX" H 6200 4300 50 0001 C CNN
F 3 "" H 6200 4300 50 0001 C CNN
1 6200 4100
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW50
U 1 1 5BC6CD79
P 7000 4100
F 0 "SW50" H 7000 4385 50 0000 C CNN
F 1 "Z" H 7000 4294 50 0000 C CNN
F 2 "unikbd:Key_MX" H 7000 4300 50 0001 C CNN
F 3 "" H 7000 4300 50 0001 C CNN
1 7000 4100
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW58
U 1 1 5BC6CD80
P 8600 4100
F 0 "SW58" H 8600 4385 50 0000 C CNN
F 1 "Q" H 8600 4294 50 0000 C CNN
F 2 "unikbd:Key_MX" H 8600 4300 50 0001 C CNN
F 3 "" H 8600 4300 50 0001 C CNN
1 8600 4100
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW54
U 1 1 5BC6CD87
P 7800 4100
F 0 "SW54" H 7800 4385 50 0000 C CNN
F 1 "A" H 7800 4294 50 0000 C CNN
F 2 "unikbd:Key_MX" H 7800 4300 50 0001 C CNN
F 3 "" H 7800 4300 50 0001 C CNN
1 7800 4100
1 0 0 -1
$EndComp
$Comp
L Diode:1N4148 D37
U 1 1 5BC6CD8E
P 4000 4350
F 0 "D37" V 4046 4271 50 0000 R CNN
F 1 "1N4148" V 3955 4271 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 4000 4175 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 4000 4350 50 0001 C CNN
1 4000 4350
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D41
U 1 1 5BC6CD9C
P 4800 4350
F 0 "D41" V 4846 4271 50 0000 R CNN
F 1 "1N4148" V 4755 4271 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 4800 4175 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 4800 4350 50 0001 C CNN
1 4800 4350
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D44
U 1 1 5BC6CDA3
P 5600 4350
F 0 "D44" V 5646 4271 50 0000 R CNN
F 1 "1N4148" V 5555 4271 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 5600 4175 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 5600 4350 50 0001 C CNN
1 5600 4350
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D47
U 1 1 5BC6CDAA
P 6400 4350
F 0 "D47" V 6446 4271 50 0000 R CNN
F 1 "1N4148" V 6355 4271 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 6400 4175 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 6400 4350 50 0001 C CNN
1 6400 4350
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D51
U 1 1 5BC6CDB1
P 7200 4350
F 0 "D51" V 7246 4271 50 0000 R CNN
F 1 "1N4148" V 7155 4271 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 7200 4175 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 7200 4350 50 0001 C CNN
1 7200 4350
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D55
U 1 1 5BC6CDB8
P 8000 4350
F 0 "D55" V 8046 4271 50 0000 R CNN
F 1 "1N4148" V 7955 4271 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 8000 4175 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 8000 4350 50 0001 C CNN
1 8000 4350
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D59
U 1 1 5BC6CDBF
P 8800 4350
F 0 "D59" V 8846 4271 50 0000 R CNN
F 1 "1N4148" V 8755 4271 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 8800 4175 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 8800 4350 50 0001 C CNN
1 8800 4350
0 -1 -1 0
$EndComp
$Comp
L Switch:SW_Push SW33
U 1 1 5BC6CED6
P 3000 5000
F 0 "SW33" H 3000 5285 50 0000 C CNN
F 1 "Break" H 3000 5194 50 0000 C CNN
F 2 "unikbd:Key_MX" H 3000 5200 50 0001 C CNN
F 3 "" H 3000 5200 50 0001 C CNN
1 3000 5000
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW37
U 1 1 5BC6CEDD
P 3800 5000
F 0 "SW37" H 3800 5285 50 0000 C CNN
F 1 "Comma" H 3800 5194 50 0000 C CNN
F 2 "unikbd:Key_MX" H 3800 5200 50 0001 C CNN
F 3 "" H 3800 5200 50 0001 C CNN
1 3800 5000
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW44
U 1 1 5BC6CEE4
P 5400 5000
F 0 "SW44" H 5400 5285 50 0000 C CNN
F 1 "N" H 5400 5194 50 0000 C CNN
F 2 "unikbd:Key_MX" H 5400 5200 50 0001 C CNN
F 3 "" H 5400 5200 50 0001 C CNN
1 5400 5000
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW41
U 1 1 5BC6CEEB
P 4600 5000
F 0 "SW41" H 4600 5285 50 0000 C CNN
F 1 "M" H 4600 5194 50 0000 C CNN
F 2 "unikbd:Key_MX" H 4600 5200 50 0001 C CNN
F 3 "" H 4600 5200 50 0001 C CNN
1 4600 5000
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW47
U 1 1 5BC6CEF2
P 6200 5000
F 0 "SW47" H 6200 5285 50 0000 C CNN
F 1 "B" H 6200 5194 50 0000 C CNN
F 2 "unikbd:Key_MX" H 6200 5200 50 0001 C CNN
F 3 "" H 6200 5200 50 0001 C CNN
1 6200 5000
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW51
U 1 1 5BC6CEF9
P 7000 5000
F 0 "SW51" H 7000 5285 50 0000 C CNN
F 1 "V" H 7000 5194 50 0000 C CNN
F 2 "unikbd:Key_MX" H 7000 5200 50 0001 C CNN
F 3 "" H 7000 5200 50 0001 C CNN
1 7000 5000
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW59
U 1 1 5BC6CF00
P 8600 5000
F 0 "SW59" H 8600 5285 50 0000 C CNN
F 1 "X" H 8600 5194 50 0000 C CNN
F 2 "unikbd:Key_MX" H 8600 5200 50 0001 C CNN
F 3 "" H 8600 5200 50 0001 C CNN
1 8600 5000
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW55
U 1 1 5BC6CF07
P 7800 5000
F 0 "SW55" H 7800 5285 50 0000 C CNN
F 1 "C" H 7800 5194 50 0000 C CNN
F 2 "unikbd:Key_MX" H 7800 5200 50 0001 C CNN
F 3 "" H 7800 5200 50 0001 C CNN
1 7800 5000
1 0 0 -1
$EndComp
$Comp
L Diode:1N4148 D38
U 1 1 5BC6CF0E
P 4000 5250
F 0 "D38" V 4046 5171 50 0000 R CNN
F 1 "1N4148" V 3955 5171 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 4000 5075 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 4000 5250 50 0001 C CNN
1 4000 5250
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D34
U 1 1 5BC6CF15
P 3200 5250
F 0 "D34" V 3246 5171 50 0000 R CNN
F 1 "1N4148" V 3155 5171 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 3200 5075 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 3200 5250 50 0001 C CNN
1 3200 5250
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D42
U 1 1 5BC6CF1C
P 4800 5250
F 0 "D42" V 4846 5171 50 0000 R CNN
F 1 "1N4148" V 4755 5171 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 4800 5075 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 4800 5250 50 0001 C CNN
1 4800 5250
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D45
U 1 1 5BC6CF23
P 5600 5250
F 0 "D45" V 5646 5171 50 0000 R CNN
F 1 "1N4148" V 5555 5171 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 5600 5075 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 5600 5250 50 0001 C CNN
1 5600 5250
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D48
U 1 1 5BC6CF2A
P 6400 5250
F 0 "D48" V 6446 5171 50 0000 R CNN
F 1 "1N4148" V 6355 5171 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 6400 5075 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 6400 5250 50 0001 C CNN
1 6400 5250
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D52
U 1 1 5BC6CF31
P 7200 5250
F 0 "D52" V 7246 5171 50 0000 R CNN
F 1 "1N4148" V 7155 5171 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 7200 5075 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 7200 5250 50 0001 C CNN
1 7200 5250
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D56
U 1 1 5BC6CF38
P 8000 5250
F 0 "D56" V 8046 5171 50 0000 R CNN
F 1 "1N4148" V 7955 5171 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 8000 5075 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 8000 5250 50 0001 C CNN
1 8000 5250
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D60
U 1 1 5BC6CF3F
P 8800 5250
F 0 "D60" V 8846 5171 50 0000 R CNN
F 1 "1N4148" V 8755 5171 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 8800 5075 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 8800 5250 50 0001 C CNN
1 8800 5250
0 -1 -1 0
$EndComp
$Comp
L Switch:SW_Push SW38
U 1 1 5BC6D0AD
P 3800 5900
F 0 "SW38" H 3800 6185 50 0000 C CNN
F 1 "K" H 3800 6094 50 0000 C CNN
F 2 "unikbd:Key_MX" H 3800 6100 50 0001 C CNN
F 3 "" H 3800 6100 50 0001 C CNN
1 3800 5900
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW45
U 1 1 5BC6D0B4
P 5400 5900
F 0 "SW45" H 5400 6185 50 0000 C CNN
F 1 "H" H 5400 6094 50 0000 C CNN
F 2 "unikbd:Key_MX" H 5400 6100 50 0001 C CNN
F 3 "" H 5400 6100 50 0001 C CNN
1 5400 5900
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW42
U 1 1 5BC6D0BB
P 4600 5900
F 0 "SW42" H 4600 6185 50 0000 C CNN
F 1 "J" H 4600 6094 50 0000 C CNN
F 2 "unikbd:Key_MX" H 4600 6100 50 0001 C CNN
F 3 "" H 4600 6100 50 0001 C CNN
1 4600 5900
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW48
U 1 1 5BC6D0C2
P 6200 5900
F 0 "SW48" H 6200 6185 50 0000 C CNN
F 1 "G" H 6200 6094 50 0000 C CNN
F 2 "unikbd:Key_MX" H 6200 6100 50 0001 C CNN
F 3 "" H 6200 6100 50 0001 C CNN
1 6200 5900
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW52
U 1 1 5BC6D0C9
P 7000 5900
F 0 "SW52" H 7000 6185 50 0000 C CNN
F 1 "F" H 7000 6094 50 0000 C CNN
F 2 "unikbd:Key_MX" H 7000 6100 50 0001 C CNN
F 3 "" H 7000 6100 50 0001 C CNN
1 7000 5900
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW60
U 1 1 5BC6D0D0
P 8600 5900
F 0 "SW60" H 8600 6185 50 0000 C CNN
F 1 "S" H 8600 6094 50 0000 C CNN
F 2 "unikbd:Key_MX" H 8600 6100 50 0001 C CNN
F 3 "" H 8600 6100 50 0001 C CNN
1 8600 5900
1 0 0 -1
$EndComp
$Comp
L Switch:SW_Push SW56
U 1 1 5BC6D0D7
P 7800 5900
F 0 "SW56" H 7800 6185 50 0000 C CNN
F 1 "D" H 7800 6094 50 0000 C CNN
F 2 "unikbd:Key_MX" H 7800 6100 50 0001 C CNN
F 3 "" H 7800 6100 50 0001 C CNN
1 7800 5900
1 0 0 -1
$EndComp
$Comp
L Diode:1N4148 D39
U 1 1 5BC6D0DE
P 4000 6150
F 0 "D39" V 4046 6071 50 0000 R CNN
F 1 "1N4148" V 3955 6071 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 4000 5975 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 4000 6150 50 0001 C CNN
1 4000 6150
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D43
U 1 1 5BC6D0EC
P 4800 6150
F 0 "D43" V 4846 6071 50 0000 R CNN
F 1 "1N4148" V 4755 6071 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 4800 5975 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 4800 6150 50 0001 C CNN
1 4800 6150
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D46
U 1 1 5BC6D0F3
P 5600 6150
F 0 "D46" V 5646 6071 50 0000 R CNN
F 1 "1N4148" V 5555 6071 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 5600 5975 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 5600 6150 50 0001 C CNN
1 5600 6150
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D49
U 1 1 5BC6D0FA
P 6400 6150
F 0 "D49" V 6446 6071 50 0000 R CNN
F 1 "1N4148" V 6355 6071 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 6400 5975 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 6400 6150 50 0001 C CNN
1 6400 6150
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D53
U 1 1 5BC6D101
P 7200 6150
F 0 "D53" V 7246 6071 50 0000 R CNN
F 1 "1N4148" V 7155 6071 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 7200 5975 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 7200 6150 50 0001 C CNN
1 7200 6150
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D57
U 1 1 5BC6D108
P 8000 6150
F 0 "D57" V 8046 6071 50 0000 R CNN
F 1 "1N4148" V 7955 6071 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 8000 5975 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 8000 6150 50 0001 C CNN
1 8000 6150
0 -1 -1 0
$EndComp
$Comp
L Diode:1N4148 D61
U 1 1 5BC6D10F
P 8800 6150
F 0 "D61" V 8846 6071 50 0000 R CNN
F 1 "1N4148" V 8755 6071 50 0000 R CNN
F 2 "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal" H 8800 5975 50 0001 C CNN
F 3 "http://www.nxp.com/documents/data_sheet/1N4148_1N4448.pdf" H 8800 6150 50 0001 C CNN
1 8800 6150
0 -1 -1 0
$EndComp
Connection ~ 4000 3600
Wire Wire Line
4000 3600 4800 3600
Connection ~ 4800 3600
Connection ~ 7200 3600
Wire Wire Line
7200 3600 8000 3600
Connection ~ 8000 3600
Wire Wire Line
8000 3600 8800 3600
Connection ~ 4000 4500
Wire Wire Line
4000 4500 4800 4500
Connection ~ 4800 4500
Wire Wire Line
4800 4500 5600 4500
Connection ~ 5600 4500
Wire Wire Line
5600 4500 6400 4500
Connection ~ 6400 4500
Wire Wire Line
6400 4500 7200 4500
Connection ~ 7200 4500
Wire Wire Line
7200 4500 8000 4500
Connection ~ 8000 4500
Wire Wire Line
8000 4500 8800 4500
Wire Wire Line
3200 5400 4000 5400
Connection ~ 4000 5400
Wire Wire Line
4000 5400 4800 5400
Connection ~ 4800 5400
Wire Wire Line
4800 5400 5600 5400
Connection ~ 5600 5400
Wire Wire Line
5600 5400 6400 5400
Connection ~ 6400 5400
Wire Wire Line
6400 5400 7200 5400
Connection ~ 7200 5400
Wire Wire Line
7200 5400 8000 5400
Connection ~ 8000 5400
Wire Wire Line
8000 5400 8800 5400
Connection ~ 4000 6300
Wire Wire Line
4000 6300 4800 6300
Connection ~ 4800 6300
Wire Wire Line
4800 6300 5600 6300
Connection ~ 5600 6300
Wire Wire Line
5600 6300 6400 6300
Connection ~ 6400 6300
Wire Wire Line
6400 6300 7200 6300
Connection ~ 7200 6300
Wire Wire Line
7200 6300 8000 6300
Connection ~ 8000 6300
Wire Wire Line
8000 6300 8800 6300
Wire Wire Line
4000 5900 4000 6000
Wire Wire Line
4800 5900 4800 6000
Wire Wire Line
5600 5900 5600 6000
Wire Wire Line
6400 5900 6400 6000
Wire Wire Line
7200 5900 7200 6000
Wire Wire Line
8000 5900 8000 6000
Wire Wire Line
8800 6000 8800 5900
Wire Wire Line
8800 5000 8800 5100
Wire Wire Line
8000 5000 8000 5100
Wire Wire Line
7200 5000 7200 5100
Wire Wire Line
5600 5100 5600 5000
Wire Wire Line
6400 5100 6400 5000
Wire Wire Line
4800 5100 4800 5000
Wire Wire Line
4000 5100 4000 5000
Wire Wire Line
3200 5100 3200 5000
Wire Wire Line
4000 3200 4000 3300
Wire Wire Line
4000 4100 4000 4200
Wire Wire Line
4800 4100 4800 4200
Wire Wire Line
5600 4200 5600 4100
Wire Wire Line
6400 4200 6400 4100
Wire Wire Line
7200 4200 7200 4100
Wire Wire Line
8000 4200 8000 4100
Wire Wire Line
8800 4200 8800 4100
Wire Wire Line
4800 3300 4800 3200
Wire Wire Line
7200 3200 7200 3300
Wire Wire Line
8000 3200 8000 3300
Wire Wire Line
8800 3200 8800 3300
Wire Wire Line
1450 2500 2800 2500
Wire Wire Line
1450 2300 3600 2300
Wire Wire Line
3600 2300 3600 3200
Connection ~ 3600 3200
Wire Wire Line
3600 3200 3600 4100
Connection ~ 3600 4100
Wire Wire Line
3600 4100 3600 5000
Connection ~ 3600 5000
Wire Wire Line
3600 5000 3600 5900
Wire Wire Line
1450 2100 4400 2100
Wire Wire Line
4400 2100 4400 3200
Connection ~ 4400 3200
Wire Wire Line
4400 3200 4400 4100
Connection ~ 4400 4100
Wire Wire Line
4400 4100 4400 5000
Connection ~ 4400 5000
Wire Wire Line
4400 5000 4400 5900
Wire Wire Line
1450 1900 5200 1900
Connection ~ 5200 4100
Wire Wire Line
5200 4100 5200 5000
Connection ~ 5200 5000
Wire Wire Line
5200 5000 5200 5900
Wire Wire Line
1450 1700 6000 1700
Connection ~ 6000 4100
Wire Wire Line
6000 4100 6000 5000
Connection ~ 6000 5000
Wire Wire Line
6000 5000 6000 5900
Wire Wire Line
1450 1500 6800 1500
Wire Wire Line
6800 1500 6800 3200
Connection ~ 6800 3200
Wire Wire Line
6800 3200 6800 4100
Connection ~ 6800 4100
Wire Wire Line
6800 4100 6800 5000
Connection ~ 6800 5000
Wire Wire Line
6800 5000 6800 5900
Wire Wire Line
1450 1300 7600 1300
Wire Wire Line
7600 1300 7600 3200
Connection ~ 7600 3200
Wire Wire Line
7600 3200 7600 4100
Connection ~ 7600 4100
Wire Wire Line
7600 4100 7600 5000
Connection ~ 7600 5000
Wire Wire Line
7600 5000 7600 5900
Wire Wire Line
1450 1100 8400 1100
Wire Wire Line
8400 1100 8400 3200
Connection ~ 8400 3200
Wire Wire Line
8400 3200 8400 4100
Connection ~ 8400 4100
Wire Wire Line
8400 4100 8400 5000
Connection ~ 8400 5000
Wire Wire Line
8400 5000 8400 5900
Connection ~ 3200 5400
Text Notes 1100 7100 0 50 ~ 0
(Install either Row diodes or switch diodes. Jumper uninstalled diodes.
Text Label 2300 3600 0 50 ~ 0
Row0_keys
Text Label 2300 4500 0 50 ~ 0
Row1_keys
Text Label 2300 5400 0 50 ~ 0
Row2_keys
Wire Wire Line
5200 1900 5200 4100
Wire Wire Line
6000 1700 6000 4100
Wire Wire Line
4800 3600 7200 3600
Text Label 2300 6300 0 50 ~ 0
Row3_keys
Wire Wire Line
1450 4500 4000 4500
Wire Wire Line
1450 5400 3200 5400
Wire Wire Line
2800 2500 2800 5000
Wire Wire Line
1450 3600 4000 3600
Wire Wire Line
1450 6300 4000 6300
Text Notes 2960 4200 0 50 ~ 0
Rubout
$EndSCHEMATC

1138
hardware/keyboard-classic/keys2.sch Normal file
View File

File diff suppressed because it is too large Load Diff