Linux en hardware Mac: cómo eliminar el retraso del bloqueo de mayúsculas en el teclado de aluminio Apple MacBook Pro cuando se inicia en Linux

He descubierto cómo hacer esto. En resumen, debe enviar un "Informe de características" que consiste en los bytes 0x9, 0x0, 0x0, 0x0al dispositivo hidraw apropiado como raíz.

Puede encontrar el dispositivo hidraw correcto con este comando:

dmesg | grep Apple | grep Keyboard | grep input0 | tail -1 | sed -e 's/.*hidraw\([[:digit:]]\+\).*/\/dev\/hidraw\1/'

El código para enviar el paquete de control mágico se encuentra a continuación. Compila con gcc, toma como parámetro el dispositivo hidraw. Entonces todo el flujo es:

1. guarde el código de abajo comodisable-capslock-delay.c
2. gcc -o disable-capslock-delay disable-capslock-delay.c
3. HIDDEVICE=$(dmesg | grep Apple | grep Keyboard | grep input0 | tail -1 | sed -e 's/.*hidraw\([[:digit:]]\+\).*/\/dev\/hidraw\1/')
4. sudo ./disable-capslock-delay $HIDDEVICE

Los pasos 3 y 4 deben realizarse cada vez que reinicie (o desconecte y vuelva a conectar el teclado); puede ponerlos /etc/rc.local(o el equivalente de su distribución) para ejecutarlos en el arranque (no es necesario sudoen ese caso; y es posible que desee mover el binario compilado /usr/local/sbin/o algo así).

He realizado algunas comprobaciones de seguridad para la identificación del proveedor, la identificación del dispositivo y la longitud del descriptor del informe. Puede que tengas que cambiar los dos últimos si tu modelo es diferente al mío.

#include <linux/hidraw.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv) {
  if (argc != 2 || strcmp(argv[1], "-h") == 0) {
    printf("Pass a hidraw device as the first and only parameter!\n");
    printf("You may find the right device with:\n");
    printf("  dmesg | grep Apple | grep Keyboard | grep input0 | tail -1 | "
           "sed -e 's/.hidraw\([[:digit:]]\+\)./\/dev\/hidraw\1/'\n");
    return 1;
  }
  int fd, i, res, desc_size = 0;
  char buf[256];
  struct hidraw_devinfo info;
  char *device = argv[1];
  fd = open(device, O_RDWR | O_NONBLOCK);
  if (fd < 0) {
    perror("Unable to open device");
    return 1;
  }
  memset(&info, 0, sizeof(info));
  memset(buf, 0, sizeof(buf));
  // Get Report Descriptor Size
  res = ioctl(fd, HIDIOCGRDESCSIZE, &desc_size);
  if (res < 0) {
    perror("HIDIOCGRDESCSIZE");
  }
  if (desc_size != 75) {
    printf("Error: unexpected descriptor size %d; you've probably got "
           "the wrong hidraw device!\n", desc_size);
    return 1;
  }
  // Get Raw Info
  res = ioctl(fd, HIDIOCGRAWINFO, &info);
  if (res < 0) {
    perror("HIDIOCGRAWINFO");
  } else {
    if (info.vendor != 0x05ac) {
      printf("Error: Wrong vendor ID, make sure you got the right "
             "hidraw device!\n");
      return 1;
    }
    if (info.product != 0x0250) {
      printf("Warning: Unknown product ID 0x%x!\n", info.product);
    }
  }
  // Get Feature
  buf[0] = 0x09;  // Report Number
  res = ioctl(fd, HIDIOCGFEATURE(256), buf);
  if (res < 0) {
    perror("HIDIOCGFEATURE");
  } else {
    printf("HID Feature Report (before change):\n\t");
    for (i = 0; i < res; i++) printf("%hhx ", buf[i]);
    puts("\n");
  }
  // Set Feature
  buf[0] = 0x09;  // Report Number
  buf[1] = 0x00;  // Report data
  buf[2] = 0x00;  // padding
  buf[3] = 0x00;  // padding
  res = ioctl(fd, HIDIOCSFEATURE(4), buf);
  if (res < 0) {
    perror("HIDIOCSFEATURE");
  } else {
    printf("Caps lock delay disabled.\n");
  }
  // Get Feature
  buf[0] = 0x09;  // Report Number
  res = ioctl(fd, HIDIOCGFEATURE(256), buf);
  if (res < 0) {
    perror("HIDIOCGFEATURE");
  } else {
    printf("HID Feature Report (after change):\n\t");
    for (i = 0; i < res; i++) printf("%hhx ", buf[i]);
    puts("\n");
  }
  close(fd);
  return 0;
}

Aquí está la solución para macOS Sierra.

Vaya a Preferencias del sistema > Accesibilidad

Cuando la ventana de accesibilidad esté abierta, en la parte izquierda de la ventana, haga clic en Teclado

Luego estarán las 2 opciones: para teclas adhesivas y para teclas lentas: haga clic en el cuadro junto a las teclas lentas para habilitarlo, luego haga clic en el Options...botón: aparecerá una nueva ventana con un control deslizante para cambiar el retraso de aceptación, por defecto esto es en el medio. Deslice el botón completamente hacia la izquierda, para que sea el menor tiempo posible.

Ahora debería estar arreglado. No he experimentado para ver si la solución se mantiene al reiniciar, pero espero que así sea.

EDITAR: Esta parece ser una pregunta de aterrizaje popular para los usuarios que buscan eliminar el retraso en la tecla de bloqueo de mayúsculas en OS X. A partir de OS X Mojave,

Vaya a Preferencias del Sistema; Accesibilidad; Teclado; habilite Teclas lentas y entre en opciones; baje el retardo al mínimo. El único efecto secundario no deseado que he notado hasta ahora es una acción de retroceso lenta al mantenerlo presionado. Generalmente uso CMD+A / CMD+SHIFT+L/R / CMD+SHIFT+CTRL+L/R de todos modos, así que no es un gran problema.

A partir de El Capitán y antes,

La solución es bastante difícil de alcanzar, y realmente no sabría que la eliminó a menos que estuviera tratando específicamente de deshacerse de ella en primer lugar. La forma en que les mostraré es puramente para la última versión (actual) de OSX, Yosemite. Sin embargo, puede aplicar absolutamente este método a versiones anteriores y futuras.

La solución es sencilla. Si navega a Teclado en las preferencias del sistema a través del logotipo de Apple en la esquina superior izquierda, llegará a esta pantalla

Si hace clic en el botón de teclas modificadoras, puede cambiar la función de cada una de las teclas que son programables. Todo lo que tiene que hacer es configurar la tecla de bloqueo de mayúsculas para que no realice ninguna acción y presionar ok para regresar al menú del teclado. Una vez hecho esto, vuelva a las teclas modificadoras y cambie la tecla de bloqueo de mayúsculas a bloqueo de mayúsculas y esto eliminará la demora. Tenga en cuenta que esta solución permanece vigente hasta que duerme, reinicia o apaga el dispositivo. En ese momento se restablece el retraso.

Son arreglos extraños, y surge la pregunta de por qué no brindan una opción para eliminar el retraso cuando este arreglo se basa puramente en software. Pero bueno, ¡al menos hay una manera!

Feliz tapado.

Elaborando la respuesta de @jmrk. Su código funciona bien para el llamado teclado de "aluminio", pero Apple también lanzó teclados inalámbricos, bajo el nombre de "teclado mágico", con identificación de producto 0x022d. (También tienen chasis de aluminio, y creo que mi modelo es de 2008 más o menos). Este producto tiene el mismo problema de bloqueo de mayúsculas, y casi el mismo código puede solucionarlo. Además de cambiar la identificación del producto, el tamaño del descriptor es 218 y los datos para enviar no son 0x00, sino 0x01:

buf[0] = 0x09;  // Report Number
buf[1] = 0x01;  // Report data

Encontré esto hoy y pensé en registrar mi respuesta aquí en caso de que ayude a alguien, incluido mi yo futuro.

Aquí hay un programa completo que soluciona el problema en ambos tipos de dispositivos. Puede pasar dispositivos ocultos adicionales, se aplicará solo a los conocidos. Así que simplemente puedes llamarlo como./a.out /dev/hidraw*

#include <linux/hidraw.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char **argv) {
  printf("Pass all devices to configure. For example, like this: %s /dev/hidraw*\n", argv[0]);
  int expected_desc_size;
  char data_to_set;
  for (int argnum=1;argnum<argc;argnum++) {
    printf("Trying to configure %s...\n", argv[argnum]);
    
    int fd, i, res, desc_size = 0;
    char buf[256];
    struct hidraw_devinfo info;
    char *device = argv[argnum];
    fd = open(device, O_RDWR | O_NONBLOCK);
    if (fd < 0) {
      perror("Unable to open device");
      return 1;
    }
    memset(&info, 0, sizeof(info));
    memset(buf, 0, sizeof(buf));
    
    // Get Raw Info
    res = ioctl(fd, HIDIOCGRAWINFO, &info);
    if (res < 0) {
      perror("HIDIOCGRAWINFO");
      return 1;
    }
    if (info.vendor == 0x05ac) {
      printf("Apple device found!\n");
    } else {
      printf("Not an apple device.\n");
      continue;
    }
    if (info.product == 0x022d) {
      printf("We have a 'magic' keyboard\n");
      expected_desc_size = 218;
      data_to_set = 1;
    } else if (info.product == 0x0250) {
      printf("We have an 'aluminium' keyboard\n");
      expected_desc_size = 75;
      data_to_set = 0;
    }
    else {
      printf("Warning: Unknown product ID 0x%x!\n", info.product);
      continue;
    }
    // Get Report Descriptor Size
    res = ioctl(fd, HIDIOCGRDESCSIZE, &desc_size);
    if (res < 0) {
      perror("HIDIOCGRDESCSIZE");
      return 1;
    }
    if (desc_size != expected_desc_size) {
      printf("Error: unexpected descriptor size %d; panic'ing", desc_size);
      return 1;
    }
    // Get Feature
    buf[0] = 0x09;  // Report Number
    res = ioctl(fd, HIDIOCGFEATURE(256), buf);
    if (res < 0) {
      perror("HIDIOCGFEATURE");
    } else {
      printf("HID Feature Report (before change):\n\t");
      for (i = 0; i < res; i++) printf("%hhx ", buf[i]);
      puts("\n");
    }
      
    // Set Feature
    buf[0] = 0x09;  // Report Number
    buf[1] = data_to_set;  // Report data
    buf[2] = 0x00;  // padding
    buf[3] = 0x00;  // padding
    res = ioctl(fd, HIDIOCSFEATURE(4), buf);
    if (res < 0) {
      perror("HIDIOCSFEATURE");
    } else {
      printf("Caps lock delay disabled.\n");
    }
    // Get Feature
    buf[0] = 0x09;  // Report Number
    res = ioctl(fd, HIDIOCGFEATURE(256), buf);
    if (res < 0) {
      perror("HIDIOCGFEATURE");
      return 1;
    } 
    printf("HID Feature Report (after change):\n\t");
    for (i = 0; i < res; i++) printf("%hhx ", buf[i]);
    puts("\n");
    close(fd);
    }
  return 0;
}

Sé con certeza que el retraso del bloqueo de mayúsculas es una característica del firmware en el teclado, por lo que puede estar seguro de que el tiempo de retraso ocurre sin importar qué sistema operativo esté manejando el teclado en este momento.

También sé que Apple no ofrece una ruta para actualizar el firmware a un nivel inferior, por lo que todos tendremos que esperar hasta que alguien con suficiente experiencia en hardware publique en un blog las herramientas y los pasos que realizaron para engañar al hardware para que cargue el firmware anterior (o proporcionar lo que parece un firmware más nuevo que hace retroceder el retraso a cómo funcionaba antes sin ningún retraso).

Pido disculpas por la falta de respuesta, pero el camino para lograr esto está bien iluminado y puede ayudar a otros a tomar medidas (seleccionar un teclado más antiguo o abstenerse de actualizar el firmware) mientras esperamos que se implemente una solución real. un temporizador corto o nulo en la tecla de bloqueo de mayúsculas.

¡Vaya a preferencias del sistema> accesibilidad> teclado> habilitar teclas lentas> cambiar el retraso de aceptación completamente a la izquierda (corto)! Esto funcionó para mí.

La solución "activar/desactivar CapsLock-NoAction" a la que se refiere el OP funciona tanto en mi teclado Mac con cable como en mi teclado MacBookPro. Bradley dice que esto solo funciona en Yosemite, pero lo he usado con éxito en Snow Leopard (10.6.8) y Mavericks (10.9.5). También probé esto dentro de una máquina virtual Kubuntu y Caps Lock continuó funcionando correctamente dentro de la máquina virtual.

• Abra la Preferencia del sistema de teclado y haga clic en Modifier Keys...:

• Establezca la tecla Bloq Mayús en No Actiony haga clic en OK:

• Vuelva a hacer clic en Modifier Keys...y configure la tecla Bloq Mayús en Caps Locky haga clic en OK:

Esto solo permanece vigente hasta el próximo reinicio.

1. Descargue e instale el siguiente software

• mosquetón
• cuchara martillo

1. Use la tecla Bloq Mayús de los mapas de Karabiner para F19.
2. Edite init.luadebajo de la ruta ~/.hammerspoon, pegue el código a continuación.

pressedF19 = function()
    hs.hid.capslock.toggle()
end

hs.hotkey.bind({}, 'F19', pressedF19, nil)

Luego vuelva a cargar la configuración de hammerspoon para que los cambios surtan efecto.

Vea mi blog aquí http://hellohtml5.com/2019/04/25/best-way-to-disable-capslock-delay-on-mac/

He escrito una herramienta de código abierto muy ligera para arreglar exactamente eso:

https://github.com/gkpln3/CapsLockNoDelay