mirror of https://github.com/Keychron/qmk_firmware.git synced 2024-12-12 05:06:38 +06:00

2020 November 28 Breaking Changes Update (#11053 )

* Branch point for 2020 November 28 Breaking Change                                                

* Remove matrix_col_t to allow MATRIX_ROWS > 32 (#10183)                                           

* Add support for soft serial to ATmega32U2 (#10204)                                               

* Change MIDI velocity implementation to allow direct control of velocity value (#9940)            

* Add ability to build a subset of all keyboards based on platform.                                

* Actually use eeprom_driver_init().                                                               

* Make bootloader_jump weak for ChibiOS. (#10417)                                                  

* Joystick 16-bit support (#10439)                                                                 

* Per-encoder resolutions (#10259)                                                                 

* Share button state from mousekey to pointing_device (#10179)                                     

* Add hotfix for chibios keyboards not wake (#10088)                                               

* Add advanced/efficient RGB Matrix Indicators (#8564)                                             

* Naming change.                                                                                   

* Support for STM32 GPIOF,G,H,I,J,K (#10206)                                                       

* Add milc as a dependency and remove the installed milc (#10563)                                  

* ChibiOS upgrade: early init conversions (#10214)                                                 

* ChibiOS upgrade: configuration file migrator (#9952)                                             

* Haptic and solenoid cleanup (#9700)                                                              

* XD75 cleanup (#10524)                                                                            

* OLED display update interval support (#10388)                                                    

* Add definition based on currently-selected serial driver. (#10716)                               

* New feature: Retro Tapping per key (#10622)                                                      

* Allow for modification of output RGB values when using rgblight/rgb_matrix. (#10638)             

* Add housekeeping task callbacks so that keyboards/keymaps are capable of executing code for each main loop iteration. (#10530)

* Rescale both ChibiOS and AVR backlighting.                                                       

* Reduce Helix keyboard build variation (#8669)                                                    

* Minor change to behavior allowing display updates to continue between task ticks (#10750)        

* Some GPIO manipulations in matrix.c change to atomic. (#10491)                                   

* qmk cformat (#10767)                                                                             

* [Keyboard] Update the Speedo firmware for v3.0 (#10657)                                          

* Maartenwut/Maarten namechange to evyd13/Evy (#10274)                                             

* [quantum] combine repeated lines of code (#10837)                                                

* Add step sequencer feature (#9703)                                                               

* aeboards/ext65 refactor (#10820)                                                                 

* Refactor xelus/dawn60 for Rev2 later (#10584)                                                    

* add DEBUG_MATRIX_SCAN_RATE_ENABLE to common_features.mk (#10824)                                 

* [Core] Added `add_oneshot_mods` & `del_oneshot_mods` (#10549)                                    

* update chibios os usb for the otg driver (#8893)                                                 

* Remove HD44780 References, Part 4 (#10735)                                                       

* [Keyboard] Add Valor FRL TKL (+refactor) (#10512)                                                

* Fix cursor position bug in oled_write_raw functions (#10800)                                     

* Fixup version.h writing when using SKIP_VERSION=yes (#10972)                                     

* Allow for certain code in the codebase assuming length of string. (#10974)                       

* Add AT90USB support for serial.c (#10706)                                                        

* Auto shift: support repeats and early registration (#9826)                                       

* Rename ledmatrix.h to match .c file (#7949)                                                      

* Split RGB_MATRIX_ENABLE into _ENABLE and _DRIVER (#10231)                                        

* Split LED_MATRIX_ENABLE into _ENABLE and _DRIVER (#10840)                                        

* Merge point for 2020 Nov 28 Breaking Change

2020-11-28 12:02:18 -08:00

5.8 KiB

Raw Blame History

Sequencer

Since QMK has experimental support for MIDI, you can now turn your keyboard into a step sequencer!

!> IMPORTANT: This feature is highly experimental, it has only been tested on a Planck EZ so far. Also, the scope will be limited to support the drum machine use-case to start with.

Enable the step sequencer

Add the following line to your rules.mk:

SEQUENCER_ENABLE = yes

By default the sequencer has 16 steps, but you can override this setting in your config.h:

#define SEQUENCER_STEPS 32

Tracks

You can program up to 8 independent tracks with the step sequencer. Select the tracks you want to edit, enable or disable some steps, and start the sequence!

Resolutions

While the tempo defines the absolute speed at which the sequencer goes through the steps, the resolution defines the granularity of these steps (from coarser to finer).

Resolution	Description
`SQ_RES_2`	Every other beat
`SQ_RES_2T`	Every 1.5 beats
`SQ_RES_4`	Every beat
`SQ_RES_4T`	Three times per 2 beats
`SQ_RES_8`	Twice per beat
`SQ_RES_8T`	Three times per beat
`SQ_RES_16`	Four times per beat
`SQ_RES_16T`	Six times per beat
`SQ_RES_32`	Eight times per beat

Keycodes

Keycode	Description
`SQ_ON`	Start the step sequencer
`SQ_OFF`	Stop the step sequencer
`SQ_TOG`	Toggle the step sequencer playback
`SQ_SALL`	Enable all the steps
`SQ_SCLR`	Disable all the steps
`SQ_S(n)`	Toggle the step `n`
`SQ_TMPD`	Decrease the tempo
`SQ_TMPU`	Increase the tempo
`SQ_R(n)`	Set the resolution to n
`SQ_RESD`	Change to the slower resolution
`SQ_RESU`	Change to the faster resolution
`SQ_T(n)`	Set `n` as the only active track or deactivate all

Functions

Function	Description
`bool is_sequencer_on(void);`	Return whether the sequencer is playing
`void sequencer_toggle(void);`	Toggle the step sequencer playback
`void sequencer_on(void);`	Start the step sequencer
`void sequencer_off(void);`	Stop the step sequencer
`bool is_sequencer_step_on(uint8_t step);`	Return whether the step is currently enabled
`void sequencer_set_step(uint8_t step, bool value);`	Enable or disable the step
`void sequencer_set_step_on();`	Enable the step
`void sequencer_set_step_off();`	Disable the step
`void sequencer_toggle_step(uint8_t step);`	Toggle the step
`void sequencer_set_all_steps(bool value);`	Enable or disable all the steps
`void sequencer_set_all_steps_on();`	Enable all the steps
`void sequencer_set_all_steps_off();`	Disable all the steps
`uint8_t sequencer_get_tempo(void);`	Return the current tempo
`void sequencer_set_tempo(uint8_t tempo);`	Set the tempo to `tempo` (between 1 and 255)
`void sequencer_increase_tempo(void);`	Increase the tempo
`void sequencer_decrease_tempo(void);`	Decrease the tempo
`sequencer_resolution_t sequencer_get_resolution(void);`	Return the current resolution
`void sequencer_set_resolution(sequencer_resolution_t resolution);`	Set the resolution to `resolution`
`void sequencer_increase_resolution(void);`	Change to the faster resolution
`void sequencer_decrease_resolution(void);`	Change to the slower resolution
`bool is_sequencer_track_active(uint8_t track);`	Return whether the track is active
`void sequencer_set_track_activation(uint8_t track, bool value);`	Activate or deactivate the `track`
`void sequencer_toggle_track_activation(uint8_t track);`	Toggle the `track`
`void sequencer_activate_track(uint8_t track);`	Activate the `track`
`void sequencer_deactivate_track(uint8_t track);`	Deactivate the `track`
`void sequencer_toggle_single_active_track(uint8_t track);`	Set `track` as the only active track or deactivate all

5.8 KiB Raw Blame History