Forum bépo

Forum des utilisateurs du bépo

Vous n'êtes pas identifié(e).

Annonce

⚠️⚠️⚠️ Ce forum va bientôt migrer vers Flarum, pour éviter de rester sur du vieux PHP non maintenu trop longtemps. Si vous avez une objection, vous pouvez venir m’en faire part sur ce topic. — Sardem FF7 ⚠️⚠️⚠️

Pages : 1 2 3 4 5

#1 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 7/9/2015 09:33:03

yeKcim

Mimoza : En dessous c’est alt+gr ce serait un problème de mettre une touche et une touche morte au même endroit. En plut AltGr+pavé num donne ↖↑↗←↔→↙↓↘↕÷×−+, et avec maj en plus ça donne ⇖⇑⇗⇐⇔⇒⇙⇓⇘⇕ c’est pratique

Le manque d’entrée/tab à droite me gène beaucoup en effet mais je n’arrive pas à trouver comment les ajouter et où. Je n’arrive pas à me passer de l’espace à droite et à gauche c’est pratique aussi…

Pas simple !

#2 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 24/8/2015 18:35:51

yeKcim

45.svg

Juste une mini correction (position L0) et une mini modification (voldown et mute intervertis)

/*
Copyright 2013 Oleg Kostyuk <cub.uanic@gmail.com>

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 2 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 <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "keycode.h"
#include "action.h"
#include "action_util.h"
#include "action_code.h"
#include "action_macro.h"
#include "action_layer.h"
#include "bootloader.h"
#include "report.h"
#include "host.h"
#include "print.h"
#include "debug.h"
#include "keymap.h"
#include "ergodox.h"


/* ErgoDox keymap definition macro */
#define KEYMAP(                                                 \
                                                                \
    /* left hand, spatial positions */                          \
    k00,k01,k02,k03,k04,k05,k06,                                \
    k10,k11,k12,k13,k14,k15,k16,                                \
    k20,k21,k22,k23,k24,k25,                                    \
    k30,k31,k32,k33,k34,k35,k36,                                \
    k40,k41,k42,k43,k44,                                        \
                            k55,k56,                            \
                                k54,                            \
                        k53,k52,k51,                            \
                                                                \
    /* right hand, spatial positions */                         \
        k07,k08,k09,k0A,k0B,k0C,k0D,                            \
        k17,k18,k19,k1A,k1B,k1C,k1D,                            \
            k28,k29,k2A,k2B,k2C,k2D,                            \
        k37,k38,k39,k3A,k3B,k3C,k3D,                            \
                k49,k4A,k4B,k4C,k4D,                            \
    k57,k58,                                                    \
    k59,                                                        \
    k5C,k5B,k5A )                                               \
                                                                \
   /* matrix positions */                                       \
   {                                                            \
    { KC_##k00,KC_##k10,KC_##k20,KC_##k30,KC_##k40,KC_NO   },   \
    { KC_##k01,KC_##k11,KC_##k21,KC_##k31,KC_##k41,KC_##k51},   \
    { KC_##k02,KC_##k12,KC_##k22,KC_##k32,KC_##k42,KC_##k52},   \
    { KC_##k03,KC_##k13,KC_##k23,KC_##k33,KC_##k43,KC_##k53},   \
    { KC_##k04,KC_##k14,KC_##k24,KC_##k34,KC_##k44,KC_##k54},   \
    { KC_##k05,KC_##k15,KC_##k25,KC_##k35,KC_NO,   KC_##k55},   \
    { KC_##k06,KC_##k16,KC_NO,   KC_##k36,KC_NO,   KC_##k56},   \
                                                                \
    { KC_##k07,KC_##k17,KC_NO,   KC_##k37,KC_NO,   KC_##k57},   \
    { KC_##k08,KC_##k18,KC_##k28,KC_##k38,KC_NO,   KC_##k58},   \
    { KC_##k09,KC_##k19,KC_##k29,KC_##k39,KC_##k49,KC_##k59},   \
    { KC_##k0A,KC_##k1A,KC_##k2A,KC_##k3A,KC_##k4A,KC_##k5A},   \
    { KC_##k0B,KC_##k1B,KC_##k2B,KC_##k3B,KC_##k4B,KC_##k5B},   \
    { KC_##k0C,KC_##k1C,KC_##k2C,KC_##k3C,KC_##k4C,KC_##k5C},   \
    { KC_##k0D,KC_##k1D,KC_##k2D,KC_##k3D,KC_##k4D,KC_NO   }    \
   }

#if defined(KEYMAP_DVORAK)
#include "keymap_dvorak.h"
#elif defined(KEYMAP_COLEMAK)
#include "keymap_colemak.h"
#elif defined(KEYMAP_WORKMAN)
#include "keymap_workman.h"
#elif defined(KEYMAP_MICRO)
#include "keymap_micro.h"
#elif defined(KEYMAP_CUB)
#include "keymap_cub.h"
#else

static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    KEYMAP(  // layer 0 : default
        // left hand
        ESC, 1,   2,   3,   4,   5,   GRV,
        RBRC,Q,   W,   E,   R,   T,   ENT,
        BSLS ,A,   S,   D,   F,   G,
        LCTL,Z,   X,   C,   V,   B,   TAB,
        HOME,PGUP,PGDN,END, LALT,
                                      LGUI, RGUI,
                                           FN17,
                                 SPC, LSFT, FN1,
						        // right hand
							   EQL, 6,   7,   8,   9,   0,   MINS,
							   BSPC,Y,   U,   I,   O,   P,   LBRC,
							        H,   J,   K,   L,   SCLN,QUOT,
							   DEL ,N,   M,   COMM,DOT, SLSH,RCTL,
	 							    RALT,LEFT,UP,  DOWN,RGHT,
						        APP,LGUI,
						        FN2 ,
						        FN1 ,RSFT, SPC
    ),

    KEYMAP(  // layer 1 : function, numpad
        // left hand
        PWR, F1,  F2,  F3,  F4,  F5,  F6,
        SLEP,F7,  F8,  F9,  F10, F11, F12,
        WAKE,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,FN12,FN6 ,FN13,FN8, FN9 ,TRNS,  
        MYCM,VOLD,MUTE,VOLU,TRNS,
                                      TRNS,TRNS,
                                           TRNS,
                                 TRNS,TRNS,TRNS,
						        // right hand
							   CAPS,NLCK,PPLS,PMNS,PSLS,PAST,PSCR,
							   TRNS,Y   ,P7,  P8,  P9,  FN15,SLCK,
							        FN16,P4,  P5,  P6,  G   ,PAUS,
							   INS ,P0  ,P1,  P2,  P3,  PDOT,TRNS,
								    MSEL,MPLY,MPRV,MNXT,MSTP,
						        TRNS,TRNS,
						        TRNS,
						        TRNS,TRNS,TRNS  
    ),

    KEYMAP(  // layer 2 : numpad
        // left hand
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,
                                      TRNS,TRNS,
                                           TRNS,
                                 TRNS,TRNS,FN1,
						        // right hand
							   TRNS,NLCK,PPLS,PMNS,PSLS,PAST,TRNS,  
							   TRNS,Y   ,P7,  P8,  P9,  FN15,TRNS,  
							        FN16,P4,  P5,  P6,  G   ,TRNS,  
							   TRNS,P0  ,P1,  P2,  P3,  PDOT,TRNS,
								    TRNS,TRNS,TRNS,TRNS,TRNS,  
						        TRNS,TRNS,
						        FN4,
						        FN1,TRNS,PENT   
    ),
    
 
    KEYMAP(  // layer 3: mirror ------ not used anymore
            // left hand
        MINS,0,   9,   8,   7,   6,   EQL,
        LBRC,P,   O,   I,   U,   Y,   BSLS,
        QUOT,SCLN,L,   K,   J,   H,
        RCTL,SLSH,DOT, COMM,M,   N,   RGUI,
        RGHT,DOWN,UP,  LEFT,RALT,
                                      TRNS,LGUI,
                                           TRNS,
                                 ENT, RSFT,NO,
						        // right hand
							   GRV, 5,   4,   3,   2,   1,   ESC,
							   RBRC,T,   R,   E,   W,   Q,   BSPC,
							        G,   F,   D,   S,   A,   TAB, 
							   DEL, B,   V,   C,   X,   Z,   LCTL,
								    TAB, END, PGDN,PGUP,HOME, 
						        LGUI,FN2,
						        TRNS,
						        NO  ,LSFT,SPC
    ),

};

/* id for user defined functions */
enum function_id {
    TEENSY_KEY,
};

/*
 * Fn action definition
 */
static const uint16_t PROGMEM fn_actions[] = {
    ACTION_FUNCTION(TEENSY_KEY),                    // FN0 - Teensy key
    ACTION_LAYER_MOMENTARY(1),                      // FN1 - switch to Layer1
    ACTION_LAYER_SET(2, ON_PRESS),                  // FN2 - set Layer2
    ACTION_LAYER_MOMENTARY(3),                      // FN3 - toggle Layer3 aka Mirror
    ACTION_LAYER_SET(0, ON_PRESS),                  // FN4 - set Layer0
    
    ACTION_MODS_KEY(MOD_LCTL, KC_A),             // FN5 - Ctrl A
    ACTION_MODS_KEY(MOD_LCTL, KC_H),             // FN6 - Ctrl C
    ACTION_MODS_KEY(MOD_LCTL, KC_SLSH),          // FN7 - Ctrl F
    ACTION_MODS_KEY(MOD_LCTL, KC_LBRC),          // FN8 - Ctrl Z (undo)
    ACTION_MODS_KEY(MOD_LCTL, KC_X),             // FN9 - Ctrl Y (redo)
    ACTION_MODS_KEY(MOD_LCTL, KC_E),             // FN10 - Ctrl P
    ACTION_MODS_KEY(MOD_LCTL, KC_K),             // FN11 - Ctrl S
    ACTION_MODS_KEY(MOD_LCTL, KC_C),             // FN12 - Ctrl X
    ACTION_MODS_KEY(MOD_LCTL, KC_U),             // FN13 - Ctrl V    
    ACTION_MODS_KEY(MOD_LGUI, KC_I),             // FN14 - Win D
    ACTION_MODS_KEY(MOD_LSFT, KC_V),             // FN15 - shift+v → bépo → numpad :
    ACTION_MODS_KEY(MOD_RALT, KC_U),             // FN16 - altgr+u → bépo → numpad ˇ   
    ACTION_MODS(MOD_LCTL | MOD_LALT)             // FN17 - Ctrl + Alt 
};

void action_function(keyrecord_t *event, uint8_t id, uint8_t opt)
{
    if (id == TEENSY_KEY) {
        clear_keyboard();
        print("\n\nJump to bootloader... ");
        _delay_ms(250);
        bootloader_jump(); // should not return
        print("not supported.\n");
    }
}

#endif


#define KEYMAPS_SIZE    (sizeof(keymaps) / sizeof(keymaps[0]))
#define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0]))

/* translates key to keycode */
uint8_t keymap_key_to_keycode(uint8_t layer, keypos_t key)
{
    if (layer < KEYMAPS_SIZE) {
        return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
    } else {
        // fall back to layer 0
        return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]);
    }
}

#if defined(KEYMAP_CUB)

// function keymap_fn_to_action will be defined in keymap_cub.h

#else
/* translates Fn keycode to action */
action_t keymap_fn_to_action(uint8_t keycode)
{
    action_t action;
    if (FN_INDEX(keycode) < FN_ACTIONS_SIZE) {
        action.code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]);
    } else {
        action.code = ACTION_NO;
    }
    return action;
}
#endif

#3 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 12/7/2015 18:11:27

yeKcim

Voici 44, retour de la symétrie (w et ç de retour à gauche) car à l’usage c’est vraiment perturbant d’avoir un clavier non symétrique. Les touches de volumes ont également été modifiées, le pavé numérique est le même en Fn ou en lock donc les touches F1, F2, F3,… font leur retour à gauche.

44.svg

Le code correspondant :

/*
Copyright 2013 Oleg Kostyuk <cub.uanic@gmail.com>

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 2 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 <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "keycode.h"
#include "action.h"
#include "action_util.h"
#include "action_code.h"
#include "action_macro.h"
#include "action_layer.h"
#include "bootloader.h"
#include "report.h"
#include "host.h"
#include "print.h"
#include "debug.h"
#include "keymap.h"
#include "ergodox.h"


/* ErgoDox keymap definition macro */
#define KEYMAP(                                                 \
                                                                \
    /* left hand, spatial positions */                          \
    k00,k01,k02,k03,k04,k05,k06,                                \
    k10,k11,k12,k13,k14,k15,k16,                                \
    k20,k21,k22,k23,k24,k25,                                    \
    k30,k31,k32,k33,k34,k35,k36,                                \
    k40,k41,k42,k43,k44,                                        \
                            k55,k56,                            \
                                k54,                            \
                        k53,k52,k51,                            \
                                                                \
    /* right hand, spatial positions */                         \
        k07,k08,k09,k0A,k0B,k0C,k0D,                            \
        k17,k18,k19,k1A,k1B,k1C,k1D,                            \
            k28,k29,k2A,k2B,k2C,k2D,                            \
        k37,k38,k39,k3A,k3B,k3C,k3D,                            \
                k49,k4A,k4B,k4C,k4D,                            \
    k57,k58,                                                    \
    k59,                                                        \
    k5C,k5B,k5A )                                               \
                                                                \
   /* matrix positions */                                       \
   {                                                            \
    { KC_##k00,KC_##k10,KC_##k20,KC_##k30,KC_##k40,KC_NO   },   \
    { KC_##k01,KC_##k11,KC_##k21,KC_##k31,KC_##k41,KC_##k51},   \
    { KC_##k02,KC_##k12,KC_##k22,KC_##k32,KC_##k42,KC_##k52},   \
    { KC_##k03,KC_##k13,KC_##k23,KC_##k33,KC_##k43,KC_##k53},   \
    { KC_##k04,KC_##k14,KC_##k24,KC_##k34,KC_##k44,KC_##k54},   \
    { KC_##k05,KC_##k15,KC_##k25,KC_##k35,KC_NO,   KC_##k55},   \
    { KC_##k06,KC_##k16,KC_NO,   KC_##k36,KC_NO,   KC_##k56},   \
                                                                \
    { KC_##k07,KC_##k17,KC_NO,   KC_##k37,KC_NO,   KC_##k57},   \
    { KC_##k08,KC_##k18,KC_##k28,KC_##k38,KC_NO,   KC_##k58},   \
    { KC_##k09,KC_##k19,KC_##k29,KC_##k39,KC_##k49,KC_##k59},   \
    { KC_##k0A,KC_##k1A,KC_##k2A,KC_##k3A,KC_##k4A,KC_##k5A},   \
    { KC_##k0B,KC_##k1B,KC_##k2B,KC_##k3B,KC_##k4B,KC_##k5B},   \
    { KC_##k0C,KC_##k1C,KC_##k2C,KC_##k3C,KC_##k4C,KC_##k5C},   \
    { KC_##k0D,KC_##k1D,KC_##k2D,KC_##k3D,KC_##k4D,KC_NO   }    \
   }

#if defined(KEYMAP_DVORAK)
#include "keymap_dvorak.h"
#elif defined(KEYMAP_COLEMAK)
#include "keymap_colemak.h"
#elif defined(KEYMAP_WORKMAN)
#include "keymap_workman.h"
#elif defined(KEYMAP_MICRO)
#include "keymap_micro.h"
#elif defined(KEYMAP_CUB)
#include "keymap_cub.h"
#else

static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    KEYMAP(  // layer 0 : default
        // left hand
        ESC, 1,   2,   3,   4,   5,   GRV,
        RBRC,Q,   W,   E,   R,   T,   ENT,
        BSLS ,A,   S,   D,   F,   G,
        LCTL,Z,   X,   C,   V,   B,   TAB,
        HOME,PGUP,PGDN,END, LALT,
                                      LGUI, RGUI,
                                           FN17,
                                 SPC, LSFT, FN1,
						        // right hand
							   EQL, 6,   7,   8,   9,   0,   MINS,
							   BSPC,Y,   U,   I,   O,   P,   LBRC,
							        H,   J,   K,   L,   SCLN,QUOT,
							   DEL ,N,   M,   COMM,DOT, SLSH,RCTL,
	 							    RALT,LEFT,UP,  DOWN,RGHT,
						        APP,LGUI,
						        FN2 ,
						        FN1 ,RSFT, SPC
    ),

    KEYMAP(  // layer 1 : function, numpad
        // left hand
        PWR, F1,  F2,  F3,  F4,  F5,  F6,
        SLEP,F7,  F8,  F9,  F10, F11, F12,
        WAKE,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,FN12,FN6 ,FN13,FN8, FN9 ,TRNS,  
        MYCM,MUTE,VOLD,VOLU,TRNS,
                                      TRNS,TRNS,
                                           TRNS,
                                 TRNS,TRNS,TRNS,
						        // right hand
							   CAPS,NLCK,PPLS,PMNS,PSLS,PAST,PSCR,
							   TRNS,Y   ,P7,  P8,  P9,  FN15,SLCK,
							        FN16,P4,  P5,  P6,  G   ,PAUS,
							   INS ,P0  ,P1,  P2,  P3,  PDOT,TRNS,
								    MSEL,MPLY,MPRV,MNXT,MSTP,
						        TRNS,TRNS,
						        TRNS,
						        TRNS,TRNS,TRNS  
    ),

    KEYMAP(  // layer 2 : numpad
        // left hand
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,
                                      TRNS,TRNS,
                                           TRNS,
                                 TRNS,TRNS,FN1,
						        // right hand
							   TRNS,NLCK,PPLS,PMNS,PSLS,PAST,TRNS,  
							   TRNS,Y   ,P7,  P8,  P9,  FN15,TRNS,  
							        FN16,P4,  P5,  P6,  G   ,TRNS,  
							   TRNS,P0  ,P1,  P2,  P3,  PDOT,TRNS,
								    TRNS,TRNS,TRNS,TRNS,TRNS,  
						        TRNS,FN4,
						        TRNS,
						        FN1,TRNS,PENT   
    ),
    
 
    KEYMAP(  // layer 3: mirror
            // left hand
        MINS,0,   9,   8,   7,   6,   EQL,
        LBRC,P,   O,   I,   U,   Y,   BSLS,
        QUOT,SCLN,L,   K,   J,   H,
        RCTL,SLSH,DOT, COMM,M,   N,   RGUI,
        RGHT,DOWN,UP,  LEFT,RALT,
                                      TRNS,LGUI,
                                           TRNS,
                                 ENT, RSFT,NO,
						        // right hand
							   GRV, 5,   4,   3,   2,   1,   ESC,
							   RBRC,T,   R,   E,   W,   Q,   BSPC,
							        G,   F,   D,   S,   A,   TAB, 
							   DEL, B,   V,   C,   X,   Z,   LCTL,
								    TAB, END, PGDN,PGUP,HOME, 
						        LGUI,FN2,
						        TRNS,
						        NO  ,LSFT,SPC
    ),

};

/* id for user defined functions */
enum function_id {
    TEENSY_KEY,
};

/*
 * Fn action definition
 */
static const uint16_t PROGMEM fn_actions[] = {
    ACTION_FUNCTION(TEENSY_KEY),                    // FN0 - Teensy key
    ACTION_LAYER_MOMENTARY(1),                      // FN1 - switch to Layer1
    ACTION_LAYER_SET(2, ON_PRESS),                  // FN2 - set Layer2
    ACTION_LAYER_MOMENTARY(3),                      // FN3 - toggle Layer3 aka Mirror
    ACTION_LAYER_SET(0, ON_PRESS),                  // FN4 - set Layer0
    
    ACTION_MODS_KEY(MOD_LCTL, KC_A),             // FN5 - Ctrl A
    ACTION_MODS_KEY(MOD_LCTL, KC_H),             // FN6 - Ctrl C
    ACTION_MODS_KEY(MOD_LCTL, KC_SLSH),          // FN7 - Ctrl F
    ACTION_MODS_KEY(MOD_LCTL, KC_LBRC),          // FN8 - Ctrl Z (undo)
    ACTION_MODS_KEY(MOD_LCTL, KC_X),             // FN9 - Ctrl Y (redo)
    ACTION_MODS_KEY(MOD_LCTL, KC_E),             // FN10 - Ctrl P
    ACTION_MODS_KEY(MOD_LCTL, KC_K),             // FN11 - Ctrl S
    ACTION_MODS_KEY(MOD_LCTL, KC_C),             // FN12 - Ctrl X
    ACTION_MODS_KEY(MOD_LCTL, KC_U),             // FN13 - Ctrl V    
    ACTION_MODS_KEY(MOD_LGUI, KC_I),             // FN14 - Win D
    ACTION_MODS_KEY(MOD_LSFT, KC_V),             // FN15 - shift+v → bépo → numpad :
    ACTION_MODS_KEY(MOD_RALT, KC_U),             // FN16 - altgr+u → bépo → numpad ˇ   
    ACTION_MODS(MOD_LCTL | MOD_LALT)             // FN17 - Ctrl + Alt 
};

void action_function(keyrecord_t *event, uint8_t id, uint8_t opt)
{
    if (id == TEENSY_KEY) {
        clear_keyboard();
        print("\n\nJump to bootloader... ");
        _delay_ms(250);
        bootloader_jump(); // should not return
        print("not supported.\n");
    }
}

#endif


#define KEYMAPS_SIZE    (sizeof(keymaps) / sizeof(keymaps[0]))
#define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0]))

/* translates key to keycode */
uint8_t keymap_key_to_keycode(uint8_t layer, keypos_t key)
{
    if (layer < KEYMAPS_SIZE) {
        return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
    } else {
        // fall back to layer 0
        return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]);
    }
}

#if defined(KEYMAP_CUB)

// function keymap_fn_to_action will be defined in keymap_cub.h

#else
/* translates Fn keycode to action */
action_t keymap_fn_to_action(uint8_t keycode)
{
    action_t action;
    if (FN_INDEX(keycode) < FN_ACTIONS_SIZE) {
        action.code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]);
    } else {
        action.code = ACTION_NO;
    }
    return action;
}
#endif

#4 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 20/2/2015 01:16:47

yeKcim

Voici 43, légère retouche de 42, je n’arrive pas à me faire à la position de tab, dans les versions précédentes, backspace et suppr étaient l’une au-dessus de l’autre c’est assez logique et agréable, entrée à gauche me manque mais je ne veux pas me passer d’espace non plus… Je laisse dans le code un layer miroir mais je n’ai plus de touche pour y accéder, finalement je trouve cette touche assez inutile :

43.svg

Le code correspondant :

/*
Copyright 2013 Oleg Kostyuk <cub.uanic@gmail.com>

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 2 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 <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "keycode.h"
#include "action.h"
#include "action_util.h"
#include "action_code.h"
#include "action_macro.h"
#include "action_layer.h"
#include "bootloader.h"
#include "report.h"
#include "host.h"
#include "print.h"
#include "debug.h"
#include "keymap.h"
#include "ergodox.h"


/* ErgoDox keymap definition macro */
#define KEYMAP(                                                 \
                                                                \
    /* left hand, spatial positions */                          \
    k00,k01,k02,k03,k04,k05,k06,                                \
    k10,k11,k12,k13,k14,k15,k16,                                \
    k20,k21,k22,k23,k24,k25,                                    \
    k30,k31,k32,k33,k34,k35,k36,                                \
    k40,k41,k42,k43,k44,                                        \
                            k55,k56,                            \
                                k54,                            \
                        k53,k52,k51,                            \
                                                                \
    /* right hand, spatial positions */                         \
        k07,k08,k09,k0A,k0B,k0C,k0D,                            \
        k17,k18,k19,k1A,k1B,k1C,k1D,                            \
            k28,k29,k2A,k2B,k2C,k2D,                            \
        k37,k38,k39,k3A,k3B,k3C,k3D,                            \
                k49,k4A,k4B,k4C,k4D,                            \
    k57,k58,                                                    \
    k59,                                                        \
    k5C,k5B,k5A )                                               \
                                                                \
   /* matrix positions */                                       \
   {                                                            \
    { KC_##k00,KC_##k10,KC_##k20,KC_##k30,KC_##k40,KC_NO   },   \
    { KC_##k01,KC_##k11,KC_##k21,KC_##k31,KC_##k41,KC_##k51},   \
    { KC_##k02,KC_##k12,KC_##k22,KC_##k32,KC_##k42,KC_##k52},   \
    { KC_##k03,KC_##k13,KC_##k23,KC_##k33,KC_##k43,KC_##k53},   \
    { KC_##k04,KC_##k14,KC_##k24,KC_##k34,KC_##k44,KC_##k54},   \
    { KC_##k05,KC_##k15,KC_##k25,KC_##k35,KC_NO,   KC_##k55},   \
    { KC_##k06,KC_##k16,KC_NO,   KC_##k36,KC_NO,   KC_##k56},   \
                                                                \
    { KC_##k07,KC_##k17,KC_NO,   KC_##k37,KC_NO,   KC_##k57},   \
    { KC_##k08,KC_##k18,KC_##k28,KC_##k38,KC_NO,   KC_##k58},   \
    { KC_##k09,KC_##k19,KC_##k29,KC_##k39,KC_##k49,KC_##k59},   \
    { KC_##k0A,KC_##k1A,KC_##k2A,KC_##k3A,KC_##k4A,KC_##k5A},   \
    { KC_##k0B,KC_##k1B,KC_##k2B,KC_##k3B,KC_##k4B,KC_##k5B},   \
    { KC_##k0C,KC_##k1C,KC_##k2C,KC_##k3C,KC_##k4C,KC_##k5C},   \
    { KC_##k0D,KC_##k1D,KC_##k2D,KC_##k3D,KC_##k4D,KC_NO   }    \
   }

#if defined(KEYMAP_DVORAK)
#include "keymap_dvorak.h"
#elif defined(KEYMAP_COLEMAK)
#include "keymap_colemak.h"
#elif defined(KEYMAP_WORKMAN)
#include "keymap_workman.h"
#elif defined(KEYMAP_MICRO)
#include "keymap_micro.h"
#elif defined(KEYMAP_CUB)
#include "keymap_cub.h"
#else

static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    KEYMAP(  // layer 0 : default
        // left hand
        ESC, 1,   2,   3,   4,   5,   GRV,
        TAB,Q,   W,   E,   R,   T,   BSPC,
        ENT ,A,   S,   D,   F,   G,
        LCTL,Z,   X,   C,   V,   B,   DEL,
        HOME,PGUP,PGDN,END, LALT,
                                      RGUI, LGUI,
                                           FN17,
                                 SPC, LSFT, FN1,
						        // right hand
							   EQL, 6,   7,   8,   9,   0,   MINS,
							   RBRC,Y,   U,   I,   O,   P,   LBRC,
							        H,   J,   K,   L,   SCLN,QUOT,
							   BSLS,N,   M,   COMM,DOT, SLSH,RCTL,
	 							    RALT,LEFT,UP,  DOWN,RGHT,
						        LGUI,FN2,
						        APP ,
						        FN1 ,RSFT, SPC
    ),

    KEYMAP(  // layer 1 : function, numpad
        // left hand
        PWR, F1,  F2,  F3,  F4,  F5,  F6,
        SLEP,PGUP,HOME,UP,  END, FN11,INS,
        WAKE,PGDN,LEFT,DOWN,RGHT,FN8 ,
        TRNS,FN7,FN12,FN6, FN13,FN9 ,TRNS,  
        MYCM,VOLD,VOLU,MUTE,TRNS,
                                      TRNS,TRNS,
                                           TRNS,
                                 TRNS,TRNS,TRNS,
						        // right hand
							   F7,  F8,  F9,  F10, F11, F12, PSCR,
							   CAPS,Y   ,P7,  P8,  P9,  FN15,SLCK,
							        FN16,P4,  P5,  P6,  G   ,PAUS,
							   TRNS,P0  ,P1,  P2,  P3,  PDOT,TRNS,
								    MSEL,MPLY,MPRV,MNXT,MSTP,
						        TRNS,TRNS,
						        TRNS,
						        TRNS,TRNS,TRNS  
    ),

    KEYMAP(  // layer 2 : numpad
        // left hand
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,
                                      TRNS,TRNS,
                                           TRNS,
                                 TRNS,TRNS,FN1,
						        // right hand
							   TRNS,NLCK,PPLS,PMNS,PSLS,PAST,PEQL,  
							   TRNS,Y   ,P7,  P8,  P9,  FN15,TRNS,  
							        FN16,P4,  P5,  P6,  G   ,TRNS,  
							   TRNS,P0  ,P1,  P2,  P3,  PDOT,TRNS,
								    TRNS,TRNS,TRNS,TRNS,TRNS,  
						        TRNS,FN4,
						        TRNS,
						        FN1,TRNS,PENT   
    ),
    
 
    KEYMAP(  // layer 3: mirror
            // left hand
        MINS,0,   9,   8,   7,   6,   EQL,
        LBRC,P,   O,   I,   U,   Y,   BSLS,
        QUOT,SCLN,L,   K,   J,   H,
        RCTL,SLSH,DOT, COMM,M,   N,   RGUI,
        RGHT,DOWN,UP,  LEFT,RALT,
                                      TRNS,LGUI,
                                           TRNS,
                                 ENT, RSFT,NO,
						        // right hand
							   GRV, 5,   4,   3,   2,   1,   ESC,
							   RBRC,T,   R,   E,   W,   Q,   BSPC,
							        G,   F,   D,   S,   A,   TAB, 
							   DEL, B,   V,   C,   X,   Z,   LCTL,
								    TAB, END, PGDN,PGUP,HOME, 
						        LGUI,FN2,
						        TRNS,
						        NO  ,LSFT,SPC
    ),

};

/* id for user defined functions */
enum function_id {
    TEENSY_KEY,
};

/*
 * Fn action definition
 */
static const uint16_t PROGMEM fn_actions[] = {
    ACTION_FUNCTION(TEENSY_KEY),                    // FN0 - Teensy key
    ACTION_LAYER_MOMENTARY(1),                      // FN1 - switch to Layer1
    ACTION_LAYER_SET(2, ON_PRESS),                  // FN2 - set Layer2
    ACTION_LAYER_MOMENTARY(3),                      // FN3 - toggle Layer3 aka Mirror
    ACTION_LAYER_SET(0, ON_PRESS),                  // FN4 - set Layer0
    
    ACTION_MODS_KEY(MOD_LCTL, KC_A),             // FN5 - Ctrl A
    ACTION_MODS_KEY(MOD_LCTL, KC_H),             // FN6 - Ctrl C
    ACTION_MODS_KEY(MOD_LCTL, KC_SLSH),          // FN7 - Ctrl F
    ACTION_MODS_KEY(MOD_LCTL, KC_LBRC),          // FN8 - Ctrl Z (undo)
    ACTION_MODS_KEY(MOD_LCTL, KC_X),             // FN9 - Ctrl Y (redo)
    ACTION_MODS_KEY(MOD_LCTL, KC_E),             // FN10 - Ctrl P
    ACTION_MODS_KEY(MOD_LCTL, KC_K),             // FN11 - Ctrl S
    ACTION_MODS_KEY(MOD_LCTL, KC_C),             // FN12 - Ctrl X
    ACTION_MODS_KEY(MOD_LCTL, KC_U),             // FN13 - Ctrl V    
    ACTION_MODS_KEY(MOD_LGUI, KC_I),             // FN14 - Win D
    ACTION_MODS_KEY(MOD_LSFT, KC_V),             // FN15 - shift+v → bépo → numpad :
    ACTION_MODS_KEY(MOD_RALT, KC_U),             // FN16 - altgr+u → bépo → numpad ˇ   
    ACTION_MODS(MOD_LCTL | MOD_LALT)             // FN17 - Ctrl + Alt 
};

void action_function(keyrecord_t *event, uint8_t id, uint8_t opt)
{
    if (id == TEENSY_KEY) {
        clear_keyboard();
        print("\n\nJump to bootloader... ");
        _delay_ms(250);
        bootloader_jump(); // should not return
        print("not supported.\n");
    }
}

#endif


#define KEYMAPS_SIZE    (sizeof(keymaps) / sizeof(keymaps[0]))
#define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0]))

/* translates key to keycode */
uint8_t keymap_key_to_keycode(uint8_t layer, keypos_t key)
{
    if (layer < KEYMAPS_SIZE) {
        return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
    } else {
        // fall back to layer 0
        return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]);
    }
}

#if defined(KEYMAP_CUB)

// function keymap_fn_to_action will be defined in keymap_cub.h

#else
/* translates Fn keycode to action */
action_t keymap_fn_to_action(uint8_t keycode)
{
    action_t action;
    if (FN_INDEX(keycode) < FN_ACTIONS_SIZE) {
        action.code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]);
    } else {
        action.code = ACTION_NO;
    }
    return action;
}
#endif

#5 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 12/2/2015 15:58:18

yeKcim

l’index pour les touches w,ç, suppr et compose

les touches de pouces longues sont très accessibles, la petite (~L1 dans la disposition 42) est accessible, les autres sont difficiles d’accès.

les copier, couper, coller sont fonctionnels oui.

#6 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 12/2/2015 10:36:26

yeKcim
jonneve a écrit :

le ALT-GR + SHIFT + ESPACE me semble quasiment inaccessible. J'imagine que je suis l'un des seuls à m'en servir (je suis traducteur, donc tenu de respecter la typographie française), mais pour moi, c'est une fonctionnalité importante du bépo qu'il ne faudrait pas détruire.

altgr en index droit, shift en pouce droit et espace en pouce gauche, ça se fait bien honnetement

jonneve a écrit :

la touche miroir, c'est quoi?

miroir + espace = entrée
miroir + X = G

les touches de la partie droite vont à gauche et inversement, ça peut éventuellement être pratique quand on à la main sur la souris. Mais finalement son accessibilité limitée limite son utilité

jonneve a écrit :

la touche SHIFT avec le pouce, c'est ABSOLUMENT GÉNIAL!

En effet

jonneve a écrit :

à quoi servent les touches étoile, le petit carré au-dessus du TAB, et le gros rectangle en dessous du Ç?

Étoile = Super Key = Touche windows
Au dessus de tab c’est backspace
Sous Ç c’est une touche compose (en fait touche windows droite, il faut ensuite configurer l’OS pour que celle-ci corresponde à la touche compose…) c’est très pratique !

jonneve a écrit :

CTRL-ENTRÉE, c'est pas trop dur? La touche CTRL me paraît limite mal placée. Personnellement, ça me plaît beaucoup de l'avoir en bas à gauche, car je l'enfonce facilement avec la main plutôt que le petit doigt, ce qui m'évite des contorsions.

J’ai toujours préféré ctrl dans le coin mais sur l’ergodox c’est cette place qui est la plus accessible. Impossible de me faire déplacer ce ctrl, vraiment, quand on a le clavier en main on ne peut pas faire autrement. La touche en dessous étant moins large elle est beaucoup moins accessible

jonneve a écrit :

CTRL-SHIFT-TAB nécessite 2 mains, alors que c'est une combinaison très utile lorsqu'on a une main sur la souris.

ctrl petit doigt, shift pouce et tab annulaire, ça doit pouvoir se faire mais il est vrai que ce n’est pas idéal

Merci pour toutes les remarques, cela permet d’envisager une version 43 :-)

#7 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 1/2/2015 11:59:39

yeKcim

Voici la réponse universelle 42 :

42.svg

tab sur la rangée de repos, fn accessible, une touche ctrl+alt pour les raccourcis claviers de fou de blender et gimp ! Certes c’est une sacrée modification mais elle est très intéressante à mon avis

Le code correspondant :

/*
Copyright 2013 Oleg Kostyuk <cub.uanic@gmail.com>

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 2 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 <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "keycode.h"
#include "action.h"
#include "action_util.h"
#include "action_code.h"
#include "action_macro.h"
#include "action_layer.h"
#include "bootloader.h"
#include "report.h"
#include "host.h"
#include "print.h"
#include "debug.h"
#include "keymap.h"
#include "ergodox.h"


/* ErgoDox keymap definition macro */
#define KEYMAP(                                                 \
                                                                \
    /* left hand, spatial positions */                          \
    k00,k01,k02,k03,k04,k05,k06,                                \
    k10,k11,k12,k13,k14,k15,k16,                                \
    k20,k21,k22,k23,k24,k25,                                    \
    k30,k31,k32,k33,k34,k35,k36,                                \
    k40,k41,k42,k43,k44,                                        \
                            k55,k56,                            \
                                k54,                            \
                        k53,k52,k51,                            \
                                                                \
    /* right hand, spatial positions */                         \
        k07,k08,k09,k0A,k0B,k0C,k0D,                            \
        k17,k18,k19,k1A,k1B,k1C,k1D,                            \
            k28,k29,k2A,k2B,k2C,k2D,                            \
        k37,k38,k39,k3A,k3B,k3C,k3D,                            \
                k49,k4A,k4B,k4C,k4D,                            \
    k57,k58,                                                    \
    k59,                                                        \
    k5C,k5B,k5A )                                               \
                                                                \
   /* matrix positions */                                       \
   {                                                            \
    { KC_##k00,KC_##k10,KC_##k20,KC_##k30,KC_##k40,KC_NO   },   \
    { KC_##k01,KC_##k11,KC_##k21,KC_##k31,KC_##k41,KC_##k51},   \
    { KC_##k02,KC_##k12,KC_##k22,KC_##k32,KC_##k42,KC_##k52},   \
    { KC_##k03,KC_##k13,KC_##k23,KC_##k33,KC_##k43,KC_##k53},   \
    { KC_##k04,KC_##k14,KC_##k24,KC_##k34,KC_##k44,KC_##k54},   \
    { KC_##k05,KC_##k15,KC_##k25,KC_##k35,KC_NO,   KC_##k55},   \
    { KC_##k06,KC_##k16,KC_NO,   KC_##k36,KC_NO,   KC_##k56},   \
                                                                \
    { KC_##k07,KC_##k17,KC_NO,   KC_##k37,KC_NO,   KC_##k57},   \
    { KC_##k08,KC_##k18,KC_##k28,KC_##k38,KC_NO,   KC_##k58},   \
    { KC_##k09,KC_##k19,KC_##k29,KC_##k39,KC_##k49,KC_##k59},   \
    { KC_##k0A,KC_##k1A,KC_##k2A,KC_##k3A,KC_##k4A,KC_##k5A},   \
    { KC_##k0B,KC_##k1B,KC_##k2B,KC_##k3B,KC_##k4B,KC_##k5B},   \
    { KC_##k0C,KC_##k1C,KC_##k2C,KC_##k3C,KC_##k4C,KC_##k5C},   \
    { KC_##k0D,KC_##k1D,KC_##k2D,KC_##k3D,KC_##k4D,KC_NO   }    \
   }

#if defined(KEYMAP_DVORAK)
#include "keymap_dvorak.h"
#elif defined(KEYMAP_COLEMAK)
#include "keymap_colemak.h"
#elif defined(KEYMAP_WORKMAN)
#include "keymap_workman.h"
#elif defined(KEYMAP_MICRO)
#include "keymap_micro.h"
#elif defined(KEYMAP_CUB)
#include "keymap_cub.h"
#else

static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    KEYMAP(  // layer 0 : default
        // left hand
        ESC, 1,   2,   3,   4,   5,   GRV,
        BSPC,Q,   W,   E,   R,   T,   RBRC,
        TAB ,A,   S,   D,   F,   G,
        LCTL,Z,   X,   C,   V,   B,   DEL,
        HOME,PGUP,PGDN,END, LALT,
                                      FN3, LGUI,
                                           FN17,
                                 SPC, LSFT, FN1,
						        // right hand
							   EQL, 6,   7,   8,   9,   0,   MINS,
							   BSLS,Y,   U,   I,   O,   P,   LBRC,
							        H,   J,   K,   L,   SCLN,QUOT,
							   RGUI,N,   M,   COMM,DOT, SLSH,RCTL,
	 							    RALT,LEFT,UP,  DOWN,RGHT,
						        LGUI,FN2,
						        APP ,
						        FN1 ,RSFT, ENT
    ),

    KEYMAP(  // layer 1 : function, numpad
        // left hand
        PWR, F1,  F2,  F3,  F4,  F5,  F6,
        SLEP,PGUP,HOME,UP,  END, FN11,INS,
        WAKE,PGDN,LEFT,DOWN,RGHT,FN8 ,
        TRNS,FN7,FN12,FN6, FN13,FN9 ,TRNS,  
        MYCM,VOLD,VOLU,MUTE,TRNS,
                                      TRNS,TRNS,
                                           TRNS,
                                 TRNS,TRNS,TRNS,
						        // right hand
							   F7,  F8,  F9,  F10, F11, F12, PSCR,
							   CAPS,Y   ,P7,  P8,  P9,  FN15,SLCK,
							        FN16,P4,  P5,  P6,  G   ,PAUS,
							   TRNS,P0  ,P1,  P2,  P3,  PDOT,TRNS,
								    MSEL,MPLY,MPRV,MNXT,MSTP,
						        TRNS,TRNS,
						        TRNS,
						        TRNS,TRNS,TRNS  
    ),

    KEYMAP(  // layer 2 : numpad
        // left hand
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,
                                      TRNS,TRNS,
                                           TRNS,
                                 TRNS,TRNS,FN1,
						        // right hand
							   TRNS,NLCK,PPLS,PMNS,PSLS,PAST,PEQL,  
							   TRNS,Y   ,P7,  P8,  P9,  FN15,TRNS,  
							        FN16,P4,  P5,  P6,  G   ,TRNS,  
							   TRNS,P0  ,P1,  P2,  P3,  PDOT,TRNS,
								    TRNS,TRNS,TRNS,TRNS,TRNS,  
						        TRNS,FN4,
						        TRNS,
						        FN1,TRNS,PENT   
    ),
    
 
    KEYMAP(  // layer 3: mirror
            // left hand
        MINS,0,   9,   8,   7,   6,   EQL,
        LBRC,P,   O,   I,   U,   Y,   BSLS,
        QUOT,SCLN,L,   K,   J,   H,
        RCTL,SLSH,DOT, COMM,M,   N,   RGUI,
        RGHT,DOWN,UP,  LEFT,RALT,
                                      TRNS,LGUI,
                                           TRNS,
                                 ENT, RSFT,NO,
						        // right hand
							   GRV, 5,   4,   3,   2,   1,   ESC,
							   RBRC,T,   R,   E,   W,   Q,   BSPC,
							        G,   F,   D,   S,   A,   TAB, 
							   DEL, B,   V,   C,   X,   Z,   LCTL,
								    TAB, END, PGDN,PGUP,HOME, 
						        LGUI,FN2,
						        TRNS,
						        NO  ,LSFT,SPC
    ),

};

/* id for user defined functions */
enum function_id {
    TEENSY_KEY,
};

/*
 * Fn action definition
 */
static const uint16_t PROGMEM fn_actions[] = {
    ACTION_FUNCTION(TEENSY_KEY),                    // FN0 - Teensy key
    ACTION_LAYER_MOMENTARY(1),                      // FN1 - switch to Layer1
    ACTION_LAYER_SET(2, ON_PRESS),                  // FN2 - set Layer2
    ACTION_LAYER_MOMENTARY(3),                      // FN3 - toggle Layer3 aka Mirror
    ACTION_LAYER_SET(0, ON_PRESS),                  // FN4 - set Layer0
    
    ACTION_MODS_KEY(MOD_LCTL, KC_A),             // FN5 - Ctrl A
    ACTION_MODS_KEY(MOD_LCTL, KC_H),             // FN6 - Ctrl C
    ACTION_MODS_KEY(MOD_LCTL, KC_SLSH),          // FN7 - Ctrl F
    ACTION_MODS_KEY(MOD_LCTL, KC_LBRC),          // FN8 - Ctrl Z (undo)
    ACTION_MODS_KEY(MOD_LCTL, KC_X),             // FN9 - Ctrl Y (redo)
    ACTION_MODS_KEY(MOD_LCTL, KC_E),             // FN10 - Ctrl P
    ACTION_MODS_KEY(MOD_LCTL, KC_K),             // FN11 - Ctrl S
    ACTION_MODS_KEY(MOD_LCTL, KC_C),             // FN12 - Ctrl X
    ACTION_MODS_KEY(MOD_LCTL, KC_U),             // FN13 - Ctrl V    
    ACTION_MODS_KEY(MOD_LGUI, KC_I),             // FN14 - Win D
    ACTION_MODS_KEY(MOD_LSFT, KC_V),             // FN15 - shift+v → bépo → numpad :
    ACTION_MODS_KEY(MOD_RALT, KC_U),             // FN16 - altgr+u → bépo → numpad ˇ   
    ACTION_MODS(MOD_LCTL | MOD_LALT)             // FN17 - Ctrl + Alt 
};

void action_function(keyrecord_t *event, uint8_t id, uint8_t opt)
{
    if (id == TEENSY_KEY) {
        clear_keyboard();
        print("\n\nJump to bootloader... ");
        _delay_ms(250);
        bootloader_jump(); // should not return
        print("not supported.\n");
    }
}

#endif


#define KEYMAPS_SIZE    (sizeof(keymaps) / sizeof(keymaps[0]))
#define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0]))

/* translates key to keycode */
uint8_t keymap_key_to_keycode(uint8_t layer, keypos_t key)
{
    if (layer < KEYMAPS_SIZE) {
        return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
    } else {
        // fall back to layer 0
        return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]);
    }
}

#if defined(KEYMAP_CUB)

// function keymap_fn_to_action will be defined in keymap_cub.h

#else
/* translates Fn keycode to action */
action_t keymap_fn_to_action(uint8_t keycode)
{
    action_t action;
    if (FN_INDEX(keycode) < FN_ACTIONS_SIZE) {
        action.code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]);
    } else {
        action.code = ACTION_NO;
    }
    return action;
}
#endif

#8 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 21/1/2015 18:06:58

yeKcim

MCMic : Ben finalement ce n’est pas très utile, il suffit de configurer le système pour avoir un azerty, un bépo et un qwerty. Pour switcher il suffit de faire Super+Espace (sous ubuntu en tout cas). Faire un configurateur n’est pas vraiment utile, le fichier texte à écrire est assez simple à faire, vraiment ! et en utilisant les commandes que j’ai répété ici c’est parfait.

#9 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 11/1/2015 17:02:37

yeKcim

rat bière sé : pas plus que BAteau

#10 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 7/1/2015 23:57:10

yeKcim

Bon du coup la version 40 ne me convient pas du tout donc à la version 41 (40c légèrement retouchée)

Je n’ai pas encore regardé comment faire fonctionner find, undo et redo. Sinon le reste est fonctionnel, même le miroir (pour l’instant elle s’applique jusqu’à ce qu’on rappuie pour la désactiver, alors que j’aurais voulu qu’elle s’active à l’appui…[update du 8 janvier, cela était du à des NO au lieu de TRNS])

41.svg

Le code correspondant :

/*
Copyright 2013 Oleg Kostyuk <cub.uanic@gmail.com>

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 2 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 <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "keycode.h"
#include "action.h"
#include "action_util.h"
#include "action_code.h"
#include "action_macro.h"
#include "action_layer.h"
#include "bootloader.h"
#include "report.h"
#include "host.h"
#include "print.h"
#include "debug.h"
#include "keymap.h"
#include "ergodox.h"


/* ErgoDox keymap definition macro */
#define KEYMAP(                                                 \
                                                                \
    /* left hand, spatial positions */                          \
    k00,k01,k02,k03,k04,k05,k06,                                \
    k10,k11,k12,k13,k14,k15,k16,                                \
    k20,k21,k22,k23,k24,k25,                                    \
    k30,k31,k32,k33,k34,k35,k36,                                \
    k40,k41,k42,k43,k44,                                        \
                            k55,k56,                            \
                                k54,                            \
                        k53,k52,k51,                            \
                                                                \
    /* right hand, spatial positions */                         \
        k07,k08,k09,k0A,k0B,k0C,k0D,                            \
        k17,k18,k19,k1A,k1B,k1C,k1D,                            \
            k28,k29,k2A,k2B,k2C,k2D,                            \
        k37,k38,k39,k3A,k3B,k3C,k3D,                            \
                k49,k4A,k4B,k4C,k4D,                            \
    k57,k58,                                                    \
    k59,                                                        \
    k5C,k5B,k5A )                                               \
                                                                \
   /* matrix positions */                                       \
   {                                                            \
    { KC_##k00,KC_##k10,KC_##k20,KC_##k30,KC_##k40,KC_NO   },   \
    { KC_##k01,KC_##k11,KC_##k21,KC_##k31,KC_##k41,KC_##k51},   \
    { KC_##k02,KC_##k12,KC_##k22,KC_##k32,KC_##k42,KC_##k52},   \
    { KC_##k03,KC_##k13,KC_##k23,KC_##k33,KC_##k43,KC_##k53},   \
    { KC_##k04,KC_##k14,KC_##k24,KC_##k34,KC_##k44,KC_##k54},   \
    { KC_##k05,KC_##k15,KC_##k25,KC_##k35,KC_NO,   KC_##k55},   \
    { KC_##k06,KC_##k16,KC_NO,   KC_##k36,KC_NO,   KC_##k56},   \
                                                                \
    { KC_##k07,KC_##k17,KC_NO,   KC_##k37,KC_NO,   KC_##k57},   \
    { KC_##k08,KC_##k18,KC_##k28,KC_##k38,KC_NO,   KC_##k58},   \
    { KC_##k09,KC_##k19,KC_##k29,KC_##k39,KC_##k49,KC_##k59},   \
    { KC_##k0A,KC_##k1A,KC_##k2A,KC_##k3A,KC_##k4A,KC_##k5A},   \
    { KC_##k0B,KC_##k1B,KC_##k2B,KC_##k3B,KC_##k4B,KC_##k5B},   \
    { KC_##k0C,KC_##k1C,KC_##k2C,KC_##k3C,KC_##k4C,KC_##k5C},   \
    { KC_##k0D,KC_##k1D,KC_##k2D,KC_##k3D,KC_##k4D,KC_NO   }    \
   }

#if defined(KEYMAP_DVORAK)
#include "keymap_dvorak.h"
#elif defined(KEYMAP_COLEMAK)
#include "keymap_colemak.h"
#elif defined(KEYMAP_WORKMAN)
#include "keymap_workman.h"
#elif defined(KEYMAP_MICRO)
#include "keymap_micro.h"
#elif defined(KEYMAP_CUB)
#include "keymap_cub.h"
#else

static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    KEYMAP(  // layer 0 : default
        // left hand
        ESC, 1,   2,   3,   4,   5,   GRV,
        RBRC,Q,   W,   E,   R,   T,   BSPC,
        BSLS,A,   S,   D,   F,   G,
        LCTL,Z,   X,   C,   V,   B,   DEL,
        HOME,PGUP,PGDN,END, TAB,
                                      FN3,  LGUI,
                                            FN1,
                                 SPC, LSFT,LALT,
						        // right hand
							   EQL, 6,   7,   8,   9,   0,   MINS,
							   RGUI,Y,   U,   I,   O,   P,   LBRC,
							        H,   J,   K,   L,   SCLN,QUOT,
							   APP ,N,   M,   COMM,DOT, SLSH,RCTL,
	 							   RALT,LEFT,UP,  DOWN,RGHT,
						        LGUI,FN2,
						        FN1,
						        LALT,RSFT, ENT
    ),

    KEYMAP(  // layer 1 : function, numpad
        // left hand
        PWR, F1,  F2,  F3,  F4,  F5,  F6,
        SLEP,PGUP,HOME,UP,  END, FN11,INS,
        WAKE,PGDN,LEFT,DOWN,RGHT,UNDO,
        TRNS,FIND,FN12, FN6,FN13,AGAIN,TRNS,  
        TRNS,VOLD,VOLU,MUTE,MYCM,
                                      TRNS,TRNS,
                                           TRNS,
                                 TRNS,TRNS,TRNS,
						        // right hand
							   F7,  F8,  F9,  F10, F11, F12, PSCR,
							   CAPS,Y   ,P7,  P8,  P9,  FN15,SLCK,
							        FN16,P4,  P5,  P6,  G   ,PAUS,
							   TRNS,P0  ,P1,  P2,  P3,  PDOT,TRNS,
								   MSEL,MPLY,MPRV,MNXT,MSTP,
						        TRNS,TRNS,
						        TRNS,
						        TRNS,TRNS,TRNS  
    ),

    KEYMAP(  // layer 2 : numpad
        // left hand
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,
                                      TRNS,TRNS,
                                           FN1,
                                 TRNS,TRNS,TRNS,
						        // right hand
							   TRNS,NLCK,PPLS,PMNS,PSLS,PAST,PEQL,  
							   TRNS,Y   ,P7,  P8,  P9,  FN15,TRNS,  
							        FN16,P4,  P5,  P6,  G   ,TRNS,  
							   TRNS,P0  ,P1,  P2,  P3,  PDOT,TRNS,
								   TRNS,TRNS,TRNS,TRNS,TRNS,  
						        TRNS,FN4,
						        FN1,
						        TRNS,TRNS,PENT   
    ),
    
 
    KEYMAP(  // layer 3: mirror
            // left hand
        MINS,0,   9,   8,   7,   6,   EQL,
        LBRC,P,   O,   I,   U,   Y,   RGUI,
        QUOT,SCLN,L,   K,   J,   H,
        RCTL,SLSH,DOT, COMM,M,   N,   APP,
        RGHT,DOWN,UP,LEFT,RALT,
                                      TRNS,LGUI,
                                           NO,
                                 ENT, RSFT,LALT,
						        // right hand
							   GRV, 5,   4,   3,   2,   1,   ESC,
							   BSPC,T,   R,   E,   W,   Q,   RBRC,
							        G,   F,   D,   S,   A,   BSLS, 
							   DEL, B,   V,   C,   X,   Z,   LCTL,
								   TAB,  END,PGDN,PGUP,HOME, 
						        LGUI,FN4,
						        NO,
						        LALT,LSFT,SPC
    ),

};

/* id for user defined functions */
enum function_id {
    TEENSY_KEY,
};

/*
 * Fn action definition
 */
static const uint16_t PROGMEM fn_actions[] = {
    ACTION_FUNCTION(TEENSY_KEY),                    // FN0 - Teensy key
    ACTION_LAYER_MOMENTARY(1),                      // FN1 - switch to Layer1
    ACTION_LAYER_SET(2, ON_PRESS),                  // FN2 - set Layer2
    ACTION_LAYER_MOMENTARY(3),                      // FN3 - toggle Layer3 aka Mirror
    ACTION_LAYER_SET(0, ON_PRESS),                  // FN4 - set Layer0
    
    ACTION_MODS_KEY(MOD_LCTL, KC_A),             // FN5 - Ctrl A
    ACTION_MODS_KEY(MOD_LCTL, KC_H),             // FN6 - Ctrl C
    ACTION_MODS_KEY(MOD_LCTL, KC_SLSH),          // FN7 - Ctrl F
    ACTION_MODS_KEY(MOD_LCTL, KC_COMM),          // FN8 - Ctrl G
    ACTION_MODS_KEY(MOD_LCTL, KC_DOT),           // FN9 - Ctrl H
    ACTION_MODS_KEY(MOD_LCTL, KC_E),             // FN10 - Ctrl P
    ACTION_MODS_KEY(MOD_LCTL, KC_K),             // FN11 - Ctrl S
    ACTION_MODS_KEY(MOD_LCTL, KC_C),             // FN12 - Ctrl X
    ACTION_MODS_KEY(MOD_LCTL, KC_U),             // FN13 - Ctrl V    
    ACTION_MODS_KEY(MOD_LGUI, KC_I),             // FN14 - Win D
    ACTION_MODS_KEY(MOD_LSFT, KC_V),             // FN15 - shift+v → bépo → numpad :
    ACTION_MODS_KEY(MOD_RALT, KC_U),             // FN16 - altgr+u → bépo → numpad ˇ   
};

void action_function(keyrecord_t *event, uint8_t id, uint8_t opt)
{
    if (id == TEENSY_KEY) {
        clear_keyboard();
        print("\n\nJump to bootloader... ");
        _delay_ms(250);
        bootloader_jump(); // should not return
        print("not supported.\n");
    }
}

#endif


#define KEYMAPS_SIZE    (sizeof(keymaps) / sizeof(keymaps[0]))
#define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0]))

/* translates key to keycode */
uint8_t keymap_key_to_keycode(uint8_t layer, keypos_t key)
{
    if (layer < KEYMAPS_SIZE) {
        return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
    } else {
        // fall back to layer 0
        return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]);
    }
}

#if defined(KEYMAP_CUB)

// function keymap_fn_to_action will be defined in keymap_cub.h

#else
/* translates Fn keycode to action */
action_t keymap_fn_to_action(uint8_t keycode)
{
    action_t action;
    if (FN_INDEX(keycode) < FN_ACTIONS_SIZE) {
        action.code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]);
    } else {
        action.code = ACTION_NO;
    }
    return action;
}
#endif

#11 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 6/1/2015 17:35:48

yeKcim

Actuellement j’utilise 40 :

40.svg

Mais finalement j’ai bien envie de revenir vers une version plus proche de ce que j’avais jusqu’alors 40c :

40c.svg

Même si alt et meta ne sont pas ultra accessible, il y a dans cette version pas mal de point qui me plaisent beaucoup. Dans cette deuxième version, j’apprécie l’accès à home end pageup pagedown que j’utilise plus que je ne le pensais. Dans les deux cas, je me galère un peu avec l’espace à gauche, pourtant c’est bien mieux pour pas mal de points (espace accessible malgré main sur souris, altgr+espace accessible sans être obligé de doubler altgr) mais les habitudes sont difficiles à changer parfois…

J’ai voulu utiliser KC_MSEL mais ça ne fait rien sur mon poste (censé sélectionné la source multimedia d’après ce que j’ai cru comprendre). De même wake ne fait rien mais je suppose que c’est mon PC ou OS, il serait intéressant que je teste sur un portable sur lequel je sais que la sortie d’hibernation est bien fonctionnelle.

#12 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 5/1/2015 00:26:58

yeKcim

chincha, un immense merci pour tes explications. Maintenant j’ai des touches multimedia, des raccourcis vers couper copier coller, une touche menu,… tout semble fonctionnel, je vais même certainement ajouter encore plein de choses du coup (genre KC_MAIL, KC_CALC, KC_MYCM ou annuler, sauvegarder,…). Comme tu dis ne pas trouver très lisible les dispos en une seule image j’ai mis ma nouvelle dispo en 2 dessins. Note : Dans ta dispo, il manque . et , dans le pavé num, ça ne te manque pas trop ?

Dites bonjour à 39 que j’utilise actuellement (c’est laborieux quand on déplace espace backspace entrée…) :

39.svg

Elle n’est pas encore finie puisque les touches . et , du pavé sont toujours les touches standard pas celles du pavé et la touche miroir n’est pas encore implémentée.

Pour obtenir cette dispo, voici le keymap.c :

/*
Copyright 2013 Oleg Kostyuk <cub.uanic@gmail.com>

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 2 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 <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "keycode.h"
#include "action.h"
#include "action_util.h"
#include "action_code.h"
#include "action_macro.h"
#include "action_layer.h"
#include "bootloader.h"
#include "report.h"
#include "host.h"
#include "print.h"
#include "debug.h"
#include "keymap.h"
#include "ergodox.h"


/* ErgoDox keymap definition macro */
#define KEYMAP(                                                 \
                                                                \
    /* left hand, spatial positions */                          \
    k00,k01,k02,k03,k04,k05,k06,                                \
    k10,k11,k12,k13,k14,k15,k16,                                \
    k20,k21,k22,k23,k24,k25,                                    \
    k30,k31,k32,k33,k34,k35,k36,                                \
    k40,k41,k42,k43,k44,                                        \
                            k55,k56,                            \
                                k54,                            \
                        k53,k52,k51,                            \
                                                                \
    /* right hand, spatial positions */                         \
        k07,k08,k09,k0A,k0B,k0C,k0D,                            \
        k17,k18,k19,k1A,k1B,k1C,k1D,                            \
            k28,k29,k2A,k2B,k2C,k2D,                            \
        k37,k38,k39,k3A,k3B,k3C,k3D,                            \
                k49,k4A,k4B,k4C,k4D,                            \
    k57,k58,                                                    \
    k59,                                                        \
    k5C,k5B,k5A )                                               \
                                                                \
   /* matrix positions */                                       \
   {                                                            \
    { KC_##k00,KC_##k10,KC_##k20,KC_##k30,KC_##k40,KC_NO   },   \
    { KC_##k01,KC_##k11,KC_##k21,KC_##k31,KC_##k41,KC_##k51},   \
    { KC_##k02,KC_##k12,KC_##k22,KC_##k32,KC_##k42,KC_##k52},   \
    { KC_##k03,KC_##k13,KC_##k23,KC_##k33,KC_##k43,KC_##k53},   \
    { KC_##k04,KC_##k14,KC_##k24,KC_##k34,KC_##k44,KC_##k54},   \
    { KC_##k05,KC_##k15,KC_##k25,KC_##k35,KC_NO,   KC_##k55},   \
    { KC_##k06,KC_##k16,KC_NO,   KC_##k36,KC_NO,   KC_##k56},   \
                                                                \
    { KC_##k07,KC_##k17,KC_NO,   KC_##k37,KC_NO,   KC_##k57},   \
    { KC_##k08,KC_##k18,KC_##k28,KC_##k38,KC_NO,   KC_##k58},   \
    { KC_##k09,KC_##k19,KC_##k29,KC_##k39,KC_##k49,KC_##k59},   \
    { KC_##k0A,KC_##k1A,KC_##k2A,KC_##k3A,KC_##k4A,KC_##k5A},   \
    { KC_##k0B,KC_##k1B,KC_##k2B,KC_##k3B,KC_##k4B,KC_##k5B},   \
    { KC_##k0C,KC_##k1C,KC_##k2C,KC_##k3C,KC_##k4C,KC_##k5C},   \
    { KC_##k0D,KC_##k1D,KC_##k2D,KC_##k3D,KC_##k4D,KC_NO   }    \
   }

#if defined(KEYMAP_DVORAK)
#include "keymap_dvorak.h"
#elif defined(KEYMAP_COLEMAK)
#include "keymap_colemak.h"
#elif defined(KEYMAP_WORKMAN)
#include "keymap_workman.h"
#elif defined(KEYMAP_MICRO)
#include "keymap_micro.h"
#elif defined(KEYMAP_CUB)
#include "keymap_cub.h"
#else

static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    KEYMAP(  // layer 0 : default
        // left hand
        ESC, 1,   2,   3,   4,   5,   GRV,
        RBRC,Q,   W,   E,   R,   T,  BSPC,
        BSLS,A,   S,   D,   F,   G,
        LCTL,Z,   X,   C,   V,   B,   DEL,
        ENT, RGUI,LGUI,LALT, TAB,
                                      PGUP,PGDN,
                                            FN3,
                                 SPC, LSFT,FN1,
						        // right hand
							   EQL, 6,   7,   8,   9,   0,   MINS,
							   TAB, Y,   U,   I,   O,   P,   LBRC,
							        H,   J,   K,   L,   SCLN,QUOT,
							   BTN2,N,   M,   COMM,DOT, SLSH,RCTL,
								   RALT,LEFT,UP,  DOWN,RGHT,
						        HOME, END,
						        FN2,
						        FN1,LSFT, ENT
    ),

    KEYMAP(  // layer 1 : function, numpad and mouse
        // left hand
        PWR, F1,  F2,  F3,  F4,  F5,  F6,
        SLEP,PGUP,HOME,UP,  END, TRNS,TRNS,
        WAKE,PGDN,LEFT,DOWN,RGHT,TRNS,
        TRNS,TRNS,FN12, FN6,FN13,TRNS,INS,  
        NO,  NO,  NO,  NO,  TRNS,
                                      VOLD,VOLU,
                                           TRNS,
                                 MUTE,TRNS,TRNS,
						        // right hand
							   F7,  F8,  F9,  F10, F11, F12, PSCR,
							   TRNS,TRNS,P7,  P8,  P9,  G,   SLCK,
							        TRNS,P4,  P5,  P6,  V,   PAUS,
							   TRNS,TRNS,P1,  P2,  P3,  P0,  TRNS,
								   TRNS,MPLY,MPRV,MNXT,MSTP,
						        CAPS,NLCK,
						        TRNS,
						        TRNS,TRNS,TRNS  
    ),

    KEYMAP(  // layer 2 : numpad comme au dessus il faudrait dot et ,
        // left hand
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,
                                      TRNS,TRNS,
                                           TRNS,
                                 TRNS,TRNS,TRNS,
						        // right hand
							   TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,  
							   TRNS,TRNS,P7,  P8,  P9,  G,   TRNS,  
							        TRNS,P4,  P5,  P6,  V,   TRNS,  
							   TRNS,TRNS,P1,  P2,  P3,  P0,  TRNS,
								   TRNS,TRNS,TRNS,TRNS,TRNS,  
						        TRNS,TRNS,
						        FN4,
						        TRNS,TRNS,TRNS   
    ),

    KEYMAP(  // layer 3: mirror, not done yet
        // left hand
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
        TRNS,TRNS,TRNS,TRNS,TRNS,
                                      TRNS,TRNS,
                                           TRNS,
                                 TRNS,TRNS,TRNS,
						        // right hand
							   TRNS,NLCK,PSLS,PAST,PAST,PMNS,BSPC,
							   TRNS,NO,  P7,  P8,  P9,  PMNS,BSPC,
							        NO,  P4,  P5,  P6,  PPLS,PENT,
							   TRNS,NO,  P1,  P2,  P3,  PPLS,PENT,
								   P0,  PDOT,SLSH,PENT,PENT,
						        TRNS,TRNS,
						        TRNS,
						        TRNS,TRNS,TRNS
    ),

};

/* id for user defined functions */
enum function_id {
    TEENSY_KEY,
};

/*
 * Fn action definition
 */
static const uint16_t PROGMEM fn_actions[] = {
    ACTION_FUNCTION(TEENSY_KEY),                    // FN0 - Teensy key
    ACTION_LAYER_MOMENTARY(1),                      // FN1 - switch to Layer1
    ACTION_LAYER_SET(2, ON_PRESS),                  // FN2 - set Layer2
    ACTION_LAYER_TOGGLE(3),                         // FN3 - toggle Layer3 aka Numpad layer
    ACTION_LAYER_SET(0, ON_PRESS),                  // FN4 - set Layer0
    
    ACTION_MODS_KEY(MOD_LCTL, KC_A),             // FN5 - Ctrl A
    ACTION_MODS_KEY(MOD_LCTL, KC_H),             // FN6 - Ctrl C
    ACTION_MODS_KEY(MOD_LCTL, KC_SLSH),          // FN7 - Ctrl F
    ACTION_MODS_KEY(MOD_LCTL, KC_COMM),          // FN8 - Ctrl G
    ACTION_MODS_KEY(MOD_LCTL, KC_DOT),           // FN9 - Ctrl H
    ACTION_MODS_KEY(MOD_LCTL, KC_E),             // FN10 - Ctrl P
    ACTION_MODS_KEY(MOD_LCTL, KC_K),             // FN11 - Ctrl S
    ACTION_MODS_KEY(MOD_LCTL, KC_C),             // FN12 - Ctrl X
    ACTION_MODS_KEY(MOD_LCTL, KC_U),             // FN13 - Ctrl V    
    ACTION_MODS_KEY(MOD_LGUI, KC_I),             // FN14 - Win D
};

void action_function(keyrecord_t *event, uint8_t id, uint8_t opt)
{
    if (id == TEENSY_KEY) {
        clear_keyboard();
        print("\n\nJump to bootloader... ");
        _delay_ms(250);
        bootloader_jump(); // should not return
        print("not supported.\n");
    }
}

#endif


#define KEYMAPS_SIZE    (sizeof(keymaps) / sizeof(keymaps[0]))
#define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0]))

/* translates key to keycode */
uint8_t keymap_key_to_keycode(uint8_t layer, keypos_t key)
{
    if (layer < KEYMAPS_SIZE) {
        return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
    } else {
        // fall back to layer 0
        return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]);
    }
}

#if defined(KEYMAP_CUB)

// function keymap_fn_to_action will be defined in keymap_cub.h

#else
/* translates Fn keycode to action */
action_t keymap_fn_to_action(uint8_t keycode)
{
    action_t action;
    if (FN_INDEX(keycode) < FN_ACTIONS_SIZE) {
        action.code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]);
    } else {
        action.code = ACTION_NO;
    }
    return action;
}
#endif

La méthode pour les linuxiens que ça intéressent :

wget https://github.com/cub-uanic/tmk_keyboard/archive/master.zip
unzip tmk_keyboard-master.zip
cd tmk_keyboard-master/keyboard/ergodox
//Personnaliser le fichier keymap.c en fonction des goûts et de la doc dans le dossier du même nom
sudo apt-get install avr-libc g++ gcc 
make -f Makefile.lufa clean
make -f Makefile.lufa

#13 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 2/1/2015 00:52:30

yeKcim

fabien, je l’utilise énormément. Elle me permet d’accéder au pavé num, aux F1, F2,… en particulier. Son accès n’est pas trop horrible (alt est bien pire) mais pour résoudre cela j’ai créé la dispo

38b.svg

qu’il va vraiment falloir que je trouve le temps de tester

#14 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 29/12/2014 23:28:20

yeKcim
robin_moussu a écrit :

j'ai vu que tu as rajouté une touche swap. Est ce que c'est vraiment utile ? Est ce qu'une touche swap seulement à gauche ne serai pas suffisante ? (je suppose que tu utilise ta souris en main droite).

Je ne me rends pas vraiment bien compte de son utilité car je n’ai pas encore migré vers cette disposition. Mais sans, je n’aurais pas de modificateurs à droite donc cela me semble indispensable.

#15 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 26/12/2014 15:13:02

yeKcim
chincha a écrit :

- : la position de Fn et Win à gauche, mais il me faut la même à droite. Le AltGr trop accessible à droite.

ils sont aussi à droite si tu maintiens la touche miroir (violette)

#16 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 26/12/2014 13:06:05

yeKcim

Merci beaucoup. Pour les LED franchement vu le peu de visibilité qu’elles ont, ce n’est pas le plus urgent. Tu n’as pas répondu pour :
38b.svg.
Je suis d’accord avec toi pour l’espace. La touche alt manque d’accessibilité dans ma version actuelle car je suis dans le même cas que toi mais en inversant ~L1 et Alt. Dans ton cas, j’aurais bien inversé tab et caps lock car à l’usage je trouve la touche du haut plus accessible, or tab est vraiment plus utile que caps lock. Pour ma part j’ai vraiment besoin d’un tab à gauche (blender). Je suis sous linux, du coup, quand tu dis que tout fonctionne (vol+, vol-, mute, couper, copier, coller) c’est sous windows ?

#17 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 26/12/2014 00:47:43

yeKcim

@chincha : bonjour. Je constate que tu t’es pas mal inspiré de ma disposition, content de voir que certaines de mes idées font des émules. Pour ma part, ma disposition actuelle est très proche de la tienne mais je suis bien tenté par ma version 38b (http://forum.bepo.fr/viewtopic.php?pid=10414#p10414) je ne sais pas si je vais sauter le pas. En fait, dans ta disposition ce que je n’aimais pas c’est un peu le peu d’accessibilité du alt et/ou ~L1. Du coup tu penses quoi de mon 38b ? J’avais hésité à mettre les F1, F2 comme toi, ça ne fait pas trop bizarre que les chiffres ne correspondent pas au numéro de F ? Pour le driver que tu as utilisé, tu as un tuto ? ou tu pourrais expliquer comment tu as procédé peut-être ? Je suis très très très fortement intéressé. (pour les liens si tu n’as pas le droit pour le moment tu peux toujours les mettre sans http, un modo pourra éventuellement arranger ça.

#18 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 22/12/2014 14:40:47

yeKcim

le num bloque, le fn est utilisable en maintien.

liste des choses qui ne fonctionnent pas :
- menu contextuel
- les touches de volume et de média (next, previous, play-pause)
- couper copier coller

Il faudrait vraiment que je regarde comment compiler le driver plus récent que celui utilisé par massdrop mais je n’ai pas pris le temps de le faire

#19 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 22/12/2014 12:03:49

yeKcim

Finalement la position de la touche miroir ne me semblait pas appropriée, du coup j’ai fait quelques modifs et je pense que cette fois je suis prêt à migrer vers une nouvelle version (la 34, je m’y étais bien habitué). Je vous présente donc la 38b (je ferai la config massdrop sous peu) :

38b.svg

Il y a du doublon en attendant de trouver des choses qui manquent pour prendre la place. J’ai sorti certaines fonctions qui ne fonctionnent pas de toute façon avec le configurateur massdrop…

@sinma: c’est un plaisir, pour l’article comme pour ce sujet
@fabien: je fais mes dessins sous inkscape. Décidément c’est une disposition de folie que tu as fait. Je me demande comment tu fais pour retenir autant de couches
@Mimoza: le altgr et ~L1 ne sont pas trop difficiles d’accès ? Le shift en pouce, essaye tu verras c’est génial et tu ne pourras plus t’en passer ! Qu’est ce que tu penses de mon 38b ?

#20 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 17/12/2014 00:21:30

yeKcim

La version que j’utilise pour le moment, 34 : 34.svg

je n’arrive pas à migrer vers une autre version. Elle contient au moins un défaut qui m’ennuie, il n’y a pas d’espace à gauche alors quand j’ai la main sur la souris… Comme l’idée de la touche miroir me semble particulièrement intéressante (merci fabien) je suis en train de faire une ébauche (mais pour l’instant j’ai quelques touches vident tongue )

38.svg

Pour l’instant j’ai mis deux touches miroir mais je ne suis pas persuadé que ce soit très pertinent (peut-être un miroir en maintien et l’autre en lock… hmm ). J’aime beaucoup cette ébauche, je me demande si après quelques finalisations, elle ne deviendra pas ma version. Enfin, j’aime bien le concept en tout cas…

#21 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 12/12/2014 10:46:25

yeKcim

la touche miroir inverse les touches entre la partie droite et la partie gauche ?
À mon sens, un des point positif du bépo est la proximité des touches permettant de taper tout l’alphabet sans aller deux rangées au dessus de la rangée de repos, déjà que je ne veux pas de typmatrix à cause de la position à la con du w, là avec le tien je ne crois pas que je pourrais me faire à l’idée qu’autant de lettres soient si loin… il me semble aussi que beaucoup de raccourcis clavier sont difficiles à faire ainsi (pour des logiciels comme gimp ou inkscape par exemple (le  ctrl+alt ne me semble pas très pratique…). Dire que parfois dans ma recherche de la disposition ultime dans cette conversation on me reprochait une mauvaise symétrie big_smile

On a là l’exemple parfais d’une disposition parfaitement adapter à ton usage, n’ayant pas du tout pour vocation d’être diffusé smile

#22 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 9/12/2014 16:43:42

yeKcim
fabien a écrit :

Question : je n'ai jamais bien compris comment utiliser le Layout Configurator de Massdrop ; quand je clique sur ces liens suis-je sensé arrivé sur vos configs ? car je ne débouche que sur du qwerty…

ne cherche pas à faire un clavier bépo avec le configurator, fait un clavier qwerty et ensuite ton clavier est à définir comme un bépo comme n’importe quel clavier donc pour la touche É du bépo il faut indiquer W dans le soft, pour W c'est ], etc…

fabien a écrit :

Je découvre avec ravissement l'outil keyboard-layout-editor.com, cela va me permettre d'arrêter de faire mes maps moi-même ! smile

Comment procédais-tu jusque là ? Avec l’éditeur de massdrop il y a quelques problèmes, dont un qui m’ennuie particulièrement (pas de touches multimédia) donc je suis vraiment très intéressé sur la méthode que tu employais pour créer ta dispo !!!

#23 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 19/11/2014 20:47:30

yeKcim

la touche fn de droite me permet de taper des chiffres sans la main gauche, la touche fn de gauche de faire des flèches et f1, f2 sans la main droite, les shift des deux cotés bah c’est pareil…

pour les fleches de droite en acces direct, c’est loin du reste, un peu comme sur tout clavier, sinon il y en a en fn à gauche directement au niveau de la position de repos

l’ergodox est un clavier symétrique je n’ai donc pas la place pour mettre le w et le ç à droite, ce sont les seuls lettres déplacés, comme il y a de la place à gauche pour faire un clavier symétrique, autant les mettres là, c’est très très très agréable et c’est ce qui à fait que je n’ai pris ni typematrix ni truly ergo (la position du w est vraiment ignoble !)

pour échap j’ai hésité à la mettre à la place du $, c’est un choix comme un autre…

#24 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 10/11/2014 17:40:22

yeKcim

La version que j’utilise pour le moment, 34 : 34.svg

et voici une nouvelle version assez différente, 35 : 35.svg

Cette nouvelle version je ne l’ai pas encore testée car j’ai prêté mon clavier à un collègue mais je l’ai pensée suite à ses réflexions sur la difficulté d’accès des touches modificatrices (il a des mains de hobbit wink). Par contre pour m’habituer ça risque d’être assez coton, je m’étais bien habitué à 34… mais je veux trouver la disposition ultime, pas ma disposition, la disposition qui met tout le monde d’accord (je suis rêveur, je sais)

#25 Re : Coin des bidouilleurs » [sujet technique] Adapter le bépo à l’ergodox » 28/10/2014 11:19:05

yeKcim

Du coup voici la config massdrop de cette nouvelle version

34.svg

https://www.massdrop.com/ext/ergodox/?r … c0aeb06d12

Pages : 1 2 3 4 5

Pied de page des forums

Propulsé par FluxBB