Skip to content

mctechnology17/zmk-config

BranchesTags

Repository files navigation

MC Technology's zmk-config for corne

MC Technology

MC Technology | YouTube MC Technology17 | Facebook MC Technology17 | Reddit


  • If you already have your corne configured with this repository and want to make a modification to your keymap, you can do it with the online ZMK-STUDIO.

  • If you already have your corne configured with this repository and want to make a modification to your keymap, you can do it with the online keymap-editor.

  • If you already have a repository and you want only the dongle option of this repository with support for zmk-studio, just add this repository as a module to your configuration, look the section THIS REPOSITORY AS A MODULE.

INTRO

Caution

I AM NOT RESPONSIBLE FOR ANY DAMAGE THIS CODE MAY CAUSE, USE IT AT YOUR OWN RISK.

Note

FEEL FREE TO MODIFY THE CODE TO YOUR LIKING OR USE WHATEVER YOU NEED. I DECIDED TO REVOKE MANY CHANGES AND RETURN TO THE BASE MAPPING, SO THAT ADVANCED AND NON-ADVANCED USERS CAN USE THIS REPOSITORY AS A BASE FOR THEIR CONFIGURATIONS. IF YOU HAVE ANY QUESTIONS, DON'T HESITATE TO ASK. IF YOU HAVE ANY SUGGESTIONS, FEEL FREE TO SUGGEST.

The objective of this repository is to serve as a base for configuring your Corne keyboard with the firmware ZMK firmware in a simple and fast way. without having to configure everything from scratch. Many of us are fascinated by customizing our keyboards, but sometimes we don't have the time or experience to do it. That is why I have decided to create this repository so that you can have a base configuration and you can modify it to your liking.

This base includes the most recent corne configurations, featuring a setup for the Corne dongle with/without an OLED screen. You can also use your keyboard WITH / WITHOUT a dongle of course. with any of the plates or screens you have.

Tested with puchi_ble_v1 (used as a dongle and as peripherals), nice_nano_v2 (used as a dongle and as peripherals), clones of nice_nano_v2 (used as a dongle and as peripherals), and the seeeduino_xiao_ble (used only as a dongle).

Main Pros
mobility and flexibility
reduction of tension and fatigue (ergonomic and ortholinear)
improved productivity
bluetooth and usb-c connection
Highly customizable programmable with ZMK firmware.
compatibility with linux, windows, macos, android, ios and more
completely wireless between the two halves and with the PC
ultra-low consumption. extends battery life to the limit
drag and drop thanks to the included uf2 bootloader
no additional software required for flashing
support for multiple devices (up to 5)
mouse keys
rgb
macros
tap dance
combos
up to 1 week of use without charger (with 100mah)
support nice-view screen and oled screen
online editor for keymap. see keymap-editor
100% open source
support for puchi-ble dongle, nice!nano v2, nice!nano v2 clones, seeeduino xiao ble and more...
support with dongle with display 128x32, 128x64 and 128x128
and more...

QUICK START

Note

  1. With this configuration you can use the corne keyboard practically immediately, you just have to follow the following steps and that's it.

  2. If you need precompiled files you can download them from the firmware folder

  3. If you have any problems, you just have to flash the reset firmwares that are in the firmware folder and that's it.

  4. Disable the builds you don't need in the file build.yaml, by default they are all activated.

zmk-studio (quick start)

This repository includes the necessary configuration to use zmk-studio without the need to configure anything else. You just have to follow the steps below:

  • fork this repository y flash the firmware to the keyboard with the uf2 files (see as below en normal procedure)
  • connect the master (dongle or central) to the PC
  • Modify the keyboard mapping on the go with ZMK Studio Web and enjoy the changes!

normal procedure

  1. Fork this repository (I appreciate if you follow me on github and youtube)
  2. Modify the keyboard mapping with keymap-editor. If you want to read about the features of this editor you can do so here: ZMK Studio Web or keymap-editor.
  3. Save changes and commit (optional)
  4. Go to actions on github and download the artifacts
    • Actions(click) -> All Workflows (click)-> Initial User Config. (here you scroll to the bottom and click)
    • Here is something called artifacts, click to download the file, it is a .zip
    • now go to download on your computer (or wherever you have downloads by default):
    • unzip the .zip file
    • Connect the nice!nano v2 microcontroller to the USB-C port of your computer
    • the microcontroller is recognized as a storage device
  5. Flash the firmware to the keyboard with the uf2 files (drag and drop and WITH dongle)
    • xiao_corne_dongle_xiao_dongle_display.uf2 for seeeduino_xiao_ble as a dongle
    • nice_corne_left_peripheral.uf2 for nice_nano_v2 as a peripheral
    • nice_corne_right.uf2 for nice_nano_v2 as a peripheral
  6. Flash the firmware to the keyboard with the uf2 files (drag and drop and WITHOUT dongle)
    • nice_corne_left.uf2 for nice_nano_v2 as a master side
    • nice_corne_right.uf2 for nice_nano_v2 as a peripheral
  7. If you need help, you can ask in the ZMK Discord
  8. Enjoy your new keyboard

Here you can see the visual changes to the configuration:

Note

This .svg image is automatically generated every time a change is made with the keymap editor. Github's workflows are responsible for building and generating the .svg file. You just have to go to the keymap-drawer folder and open the .svg file with your preferred browser if you want to see the files. The keymap-drawer configuration file is located in config. The file for the workflows is in workflows in case you want to modify it.

keymap-drawer-demo

If you want to customize this image with shapes/colors/etc. You can see these references: 1 2 3

LOCAL INSTALLATION

Before making any modifications, please see the ZMK documentation documentation.

Example of an advanced configuration hier -> 4

  1. Clone your fork of this repository.

    # Replace `mctechnology17` with your username
git clone https://github.com/mctechnology17/zmk-config.git

  2. Enter the repository.

    cd zmk-config

Here you have a preview of how the repository is organized:

zmk-config # main folder
├── LICENSE # license
├── Makefile # file for compilation
├── README.md # readme this file
├── build.yaml # config file for compilation on the github server
│   boards
│   ├── ... # other boards
│   ├── nice_nano_v2.overlay
│   ├── puchi_ble_v1.overlay
│   └── shields
│       ├── corne
│       │   ├── Kconfig.defconfig # modify if you want to add a new shield
│       │   ├── Kconfig.shield # modify if you want to add a new shield
│       │   ├── boards
│       │   │   ├── ... # other boards
│       │   ├── corne.conf # general configurations of the corne
│       │   ├── corne.dtsi # default dtsi
│       │   ├── corne.keymap # default keymap
│       │   ├── corne.zmk.yml # modify if you want to add a new shield
│       │   ├── corne_dongle_pro_micro.conf # conf dongle pro_micro pinout
│       │   ├── corne_dongle_pro_micro.overlay # properties/displays dongle
│       │   ├── corne_dongle_xiao.conf # conf dongle xiao pinout
│       │   ├── corne_dongle_xiao.overlay # properties/displays dongle
│       │   ├── corne_left.conf # conf left
│       │   ├── corne_left_peripheral.conf # config left peripheral
│       │   ├── corne_right.conf # conf right
│       │   ├── ... # other files
│       └── dongle_display
│           ├── ... # here you can modify the screen widgets
│           └── widgets
│               └── # here you can modify the screen widgets
│   config # configuration folder
│   ├── config_keymap-drawer.yaml # config file keymap-drawer
│   ├── corne.conf # general configurations of the corne
│   ├── corne.keymap # your keymap file
│   ├── keymap_german_mac_iso_zmk.h # example of definition for german mac iso
│   └── west.yml # conf to connect with the repository
├── firmware
│   └── *.uf2 # all the firmwares
├── keymap-drawer # folder with the keymap-drawer
│   ├── corne.svg # img of the keymap
│   └── corne.yaml # keymap file yaml format for keymap-drawer
└── src
    └── ... # other files

To compile with make, just run the following command:

Important

  1. You have to have docker installed on your computer to use this command.
  2. Check the makefile file for build options.
make codebase_urob # clones urob's zmk firmware and initializes it
make corne_urob # compile all the *.uf2 of the corne and copy them to the firmware folder

DISPLAY

  1. ePAPER nice-view
    • the nice-view screen is compiled by default in this repository.
  2. OLED
    • the oled screen for the dongle is enabled by default in this repository.
    • If you want to enable the OLED screen for the halves, you can do so by modifying the .conf files for their respective halves.
    • Remember to disable the nice-view screens to avoid conflict in the compilation.

Important

  1. To modify the dongle's OLED screen you can modify the .overlay file as follows for its respective board: corne_dongle_xiao.overlay and corne_dongle_pro_micro.overlay. There you can find as a comment examples for the 128x32, 128x64, 128x128 screens and nice-view for the dongle screen.
  2. For the 128x128 OLED screen model sh1107 there are no default drivers in Zephyr, so neither in ZMK, but you can add it yourself with this small tutorial (This tutorial is the same for the OLED screens mentioned above):

You just have to modify the following line:

// replace the following lines for the 128x64 screen by default
&pro_micro_i2c {
    status = "okay";

    oled: ssd1306@3c {
        compatible = "solomon,ssd1306fb";
        reg = <0x3c>;
        width = <128>;
        height = <64>;
        segment-offset = <0>;
        page-offset = <0>;
        display-offset = <0>;
        multiplex-ratio = <63>;
        segment-remap;
        com-invdir;
        inversion-on;
        prechargep = <0x22>;
    };
};
// for this (i.e. just copy and paste) replace the 128x64 screen with the 128x128 sh1107 screen
&pro_micro_i2c {
    status = "okay";
    oled: sh1106@3c {
        compatible = "sinowealth,sh1106";
        reg = <0x3c>;
        width = <120>;
        height = <128>;
        segment-offset = <0>;
        page-offset = <0>;
        display-offset = <0>;
        multiplex-ratio = <119>;
        segment-remap;
        com-invdir;
        inversion-on;
        prechargep = <0x22>;
        };
};

RGB

Warning

  1. If you use nice-view you cannot use rgb, since nice-view uses the same pinout as rgb.

If you are interested in using RGB on your keyboard you can see the configuration in the branch power/domains-and-device-runtime from this same repository.

Here is an example of what it looks like: rgb-demo

DONGLE

Tip

  1. You can connect the display to the dongle directly to the i2c port of the handwired style dongle, or you can connect it to a usb-c port of the pcb style dongle.
  2. You can see the connections in the following diagram for seeeduino_xiao_ble and for the boards with pro_micro connections as the nice_nano_v2 and the puchi_ble_v1.
  3. You can print a case for the dongle, you can see the designs below in the section Dongle Designs.
  4. You can print a pcb for the dongle, you can see the designs in the section Dongle Designs.
  5. You can program a macro that references the &bootloader action so that the dongle enters bootloader mode and you can flash the firmware again. The macros are executed on the master so this action causes the dongle to enter bootloader mode. Thanks @chadtrans for the tip!

In the following image you can see how you can connect the OLED screen to the dongle: dongle-demo

Information about this image:

  • The photo shows a seeeduino_xiao_ble dongle with an OLED 128x128 sh1107 display connected to the handwired style i2c port. This dongle acts as master.
  • The left side acts as peripheral in this case, the board is a puchi_ble_v1.
  • The right side acts as a peripheral in this case, the board is a nice_nano_v2.
  • The photo shows a clone nice_nano_v2 dongle with an OLED display connected to a traditional i2c port in a pcb style. This dongle is only for sample photo and is not connected to any device shown in the photo.

Macro example to enter bootloader mode. On your corne.keymap file you can add the following macro (Thanks @chadtrans for the tip!):

Tip

  1. You can program this macro with the online editor keymap-editor
// this is the manual way to do it
#define MACRO(name, keys)           \
name: name##_macro {                \
	compatible = "zmk,behavior-macro";\
	#binding-cells = <0>;             \
	tap-ms = <1>;                     \
	wait-ms = <1>;                    \
	bindings = <keys>;                \
};
MACRO(dongle_boot, &bootloader)
/ {
   keymap {
      compatible = "zmk,keymap";
     ... // other layers
     config_layer {
        display-name = "CON";
        bindings = <
	... // other bindings
	&dongle_boot
	... // other bindings
     };
     ... // other layers
};

USEFUL TIPS

Tip

Below are some useful tips for using your corne keyboard with this configuration.

  • You can add a reset key on each half, that's useful for when your halves disconnect/desynchronize, or something unusual happens. That way the firmware is loaded again. see reference in corne.keymap
  • You can add a bootloader activator on each half in case you don't have access to the bootloader button, it is useful in case your case is not optimized or you just want that option. see reference in corne.keymap
  • If both halves were disconnected/unsynchronized, you just have to press the reset button on both halves 10 times in a row and they will reconnect.
  • If you want to flash the firmware again you just have to connect the keyboard (that is, one half first, usually the left one) press the reset button 2 times in a row and your device is recognized as a hard disk storage drive, then just drag the file to flash and that's it. do the same with the other half.
  • Remember that if your corne only has some functional RGB lights you can activate only the ones that you have functional, it is not necessary to activate all the lights. see reference in led strip
  • You can combine the boards, for example: on the left you can have a nice_nano_v2, on the right a puchi_ble_v1 and on the dongle a seeeduino_xiao_ble or some clone nice_nano_v2, or any combination you can think of.

RELATED PROJECTS

I used this project as a reference to configure the dongles with OLED screen:

In the following animations created by @englmaxi you can see what the dongle looks like with the 128x64 OLED screen:

output

In that animation you can see the connection or output with the computer, that is, if it is through a USB or Bluetooth port. Also information about the status of both batteries.

mods

In this animation you can see the actions of the modifier keys, such as control, shift, alt, windows/mac, etc.

DONGLE DESIGNS

An example of Dongle Designs (by @rain2813): dongle-designs-demo

ZMK STUDIO

This repository includes the necessary configuration to use zmk-studio without the need to configure anything else. You just have to follow the steps below:

  • fork this repository y flash the firmware to the keyboard with the uf2 files
  • connect the master (dongle or central) to the PC
  • Modify the keyboard mapping on the go with ZMK Studio Web and enjoy the changes!

Tip

  1. For zmk-studio it is necessary to enable the &studio_unlock macro but you can skip this if you use CONFIG_ZMK_STUDIO_LOCKING=n in your zmk configuration. This is enabled by default in this repository.
  2. Remember that this has to be activated on the master and the dongle: snippet: studio-rpc-usb-uart
  3. with the cmake-args: -DCONFIG_ZMK_USB=y flag you can activate the master (dongle or central) to connect always defaults to usb.
  4. The zmk-studio only connects with USB on the web and only BLE in the app, it is useful to have a toggle key to switch between BLE and USB. (this is what I understood, if not, please correct me)

Useful links:

Reporting

Please report any and all testing results, even successful results in Discord zmk-studio If you have a genuine bug to report, please file a new GitHub Issue. With any bugs or testing results, please include all the relevant details, including the host OS, app/browser details, keyboard used, link to your config repo, etc.

MODULE INTEGRATION

Tip

  1. Remember that animations consume energy, so if you want to conserve your battery, turn off the animations!
  2. Please consult the documentation of each module that you are going to use, here I leave you the links for each one.

See module details here for more information and more configurations:

THIS REPOSITORY AS A MODULE

  1. In the config/west.yml file, add a new remote and its related project.
manifest:
  remotes:
    - name: zmkfirmware
      url-base: https://github.com/zmkfirmware
    # include corne with dongle pro_micro and xiao compatible
    - name: mctechnology17
      url-base: https://github.com/mctechnology17
  projects:
    - name: zmk
      remote: zmkfirmware
      revision: main
      import: app/west.yml
    # include corne with dongle pro_micro and xiao compatible
    - name: zmk-config
      remote: mctechnology17
      revision: main
  self:
    path: config
  1. In the build.yaml file, add the corne_dongle_pro_micro or the corne_dongle_xiao shield.
---
include:
  # example with xiao dongle without display
  - board: seeeduino_xiao_ble
    shield: corne_dongle_xiao
    cmake-args: -DCONFIG_ZMK_KEYBOARD_NAME=\"Xiao_Dongle\" -DCONFIG_ZMK_STUDIO=y
    artifact-name: xiao_corne_dongle_xiao
    snippet: studio-rpc-usb-uart
  # ... the rest of the shields
  1. Build the firmware, flash it to your keyboard, and enjoy!

INSPIRATIONS

MY OTHER PROJECTS:

  • nice!oled: nice_oled vertical widgets for oled screens with zmk (for split and non-split keyboards)
  • dongle_display!view: This is a mix between display_dongle and nice!view that allows you to use the nice!view display with your dongle.
  • oled_adapter: This module is an adapter for 128x32, 128x64 and 128x128 OLED screens, to be used on keyboards with ZMK without having to modify the shields of the keyboards.
  • qmk-config will be updated soon
  • qmk_userspace will be updated soon
  • vimtools swiss army knife for vim (features and settings that will make your life easier)
  • gm cross-platform git manager with friendly user interface
  • vim-better-header the best automated template
  • vim-executor multilanguage code executor

If you enjoy my contributions, feel free to donate. I appreciate if you follow me on github and youtube

TODO

  • Add more features to the repository
  • Update the documentation

Footnotes

  1. Keymap-drawer, https://github.com/caksoylar/keymap-drawer https://keymap-drawer.streamlit.app/ ↩

  2. caksoylar zmk-config example for keymap-drawer https://github.com/caksoylar/zmk-config ↩

  3. Install pipx, https://pipx.pypa.io/stable/ ↩

  4. Urob zmk-config, https://github.com/urob/zmk-config ↩

About

Quickly and easily configure your Wireless Corne keyboard with ZMK

www.youtube.com/c/mctechnology17

Topics

wireless dongle nrf52840 niceview corne crkbd zmk-config zmk-shield splitkb corne-keyboard nicenano xiao-ble keymap-drawer zmk-module puchi-ble puchi zmk-studio super-mini

Resources

Readme

License

MIT license
Activity

Stars

85 stars

Watchers

4 watching

Forks

62 forks
Report repository

Releases

No releases published

Packages

No packages published

Contributors 2

Languages