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 keymap-editor.

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 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.

  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.
  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

Below is a list of features currently included in this branch5 on top of the official ZMK master branch.

  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
├── config # configuration folder
│   ├── 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_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

INSPIRATIONS

MY OTHER PROJECTS:

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

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 ↩

  5. Urob ZMK Firmware: Personal fork, https://github.com/urob/zmk/ ↩

About

Personal ZMK firmware configuration for my corne wireless keyboards

www.youtube.com/c/mctechnology17

Topics

wireless dongle xiao corne crkbd zmk-config zmk-shield splitkb corne-keyboard nicenano puchi-ble xiaoble

Resources

Readme

License

MIT license
Activity

Stars

54 stars

Watchers

3 watching

Forks

41 forks
Report repository

Releases

No releases published

Packages

No packages published

Contributors 2

Languages