diff --git a/docs/ja/Getting_Started.md b/docs/ja/Getting_Started.md deleted file mode 100644 index 5327f13e3..000000000 --- a/docs/ja/Getting_Started.md +++ /dev/null @@ -1,98 +0,0 @@ -# はじめに -> Life was like a box of chocolates. You never know what you're gonna get. - -KMK は[CircuitPython](https://circuitpython.org/)の上に配置されるキーボード用の実装レイヤーです。 -そのため、[CircuitPython をサポートするほとんどのボード](https://circuitpython.org/downloads)と互換性があります。 - - 最新の安定したバージョンを使用することをおすすめします。(>5.0) -使用可能やおすすめなデバイスは[こちら](Officially_Supported_Microcontrollers.md)から確認できます。 - -CircuitPython の最適化バージョン（特定のボードの容量制限に対処した、プリインストールされた関連モジュールの選択が可能なバージョン）も提供しています。 - - -## TL;DR クイックスタートガイド -> To infinity and beyond! - -1. CircuitPython をボードに[インストール](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython)する。 - - -2. マスターブランチから[KMK のコピー](https://github.com/KMKfw/kmk_firmware/archive/refs/heads/master.zip)を取得。 - - -3. ファイルを展開し、KMK フォルダーと boot.py ファイルを USB ドライブのルート（CIRCUITPY と表示されることが多い）にコピーする。 - - -4. 同じルートディレクトリー（boot.py と同レベル）に新規で*code.py* または *main.py*のファイルを作成する。中身は以下の例とする。 - -***重要：*** GP0 / GP1 ピンを使用ボードに合わせて下さい - - -``` -print("Starting") - -import board - -from kmk.kmk_keyboard import KMKKeyboard -from kmk.keys import KC -from kmk.scanners import DiodeOrientation - -keyboard = KMKKeyboard() - -keyboard.col_pins = (board.GP0,) -keyboard.row_pins = (board.GP1,) -keyboard.diode_orientation = DiodeOrientation.COL2ROW - -keyboard.keymap = [ - [KC.A,] -] - -if __name__ == '__main__': - keyboard.go() -``` - -1. ワイヤーなどで GPIO 0 と GPIO 1（またはほかに指定したピン）を接続する。 - - -2. "A"や"Q"(キーボードのレイアウトによって異なる)が表示されたら、完成！ - - -## とりあえず一通り動くようになったので、もっとに先へ進みたい場合 -> This is your last chance. After this, there is no turning back. You take the blue pill—the story ends, you wake up in your bed and believe whatever you want to believe. You take the red pill—you stay in Wonderland, and I show you how deep the rabbit hole goes. Remember: all I'm offering is the truth. Nothing more. - -### フルサポートされているキーボードを持っている場合 - あなたのキーボードとマイコンが正式にサポートされている場合、[こちらのページ](https://github.com/KMKfw/boards)から`kb.py` と `main.py`を"flash drive"のルートに落とす必要があります。より高度な手順は[こちら](config_and_keymap.md)から確認できます。 - - Circuitpython を使用する場合、 [boot.py](/boot.py)も必要になります。 - -### ほかに自作ボードなどを持っていて、カスタマイズされた KMK を導入したい場合 - -最初にデバイスの動作や具体的なマトリックス構成についてしっかり理解してください。 -QMK チームが提供している手配線キーボード用の[ガイド](https://docs.qmk.fm/#/hand_wire)と[ドキュメント](http://pcbheaven.com/wikipages/How_Key_Matrices_Works/) を確認できます。 - -要旨をつかめてきたら： -- [ここ](config_and_keymap.md) と [ここ](keys.md)を見て、code.py / main.py ファイルをカスタイマイズできます。 - -- 使用可能なキーコードの[リファレンス](keycodes.md)があります。 - -- [インターナショナル](international.md)は、US 配列以外のキーボードにキーを追加する拡張機能で、[メディアキー](media_keys.md)は・・・メディアにキーを追加する拡張機能です。 - -さらに先へ進むと： -- [シーケンス](sequences.md) 一つのアクションで複数のキーストロークを送信するために使用します。 -- [レイヤー](layers.md)でタッチ一つでキーボードの全体の動きを変えることができます。 - -- [モドタップ](holdtap.md) でキーの押し/長押しの動作を設定し、何回押されたかによって[タップダンス](tapdance.md)を設定します。 - -RGB や分裂型などの機能を楽しめたい場合は、ビルトイン[モジュール](modules.md)と[拡張機能](extensions.md)を見てみてください！ - -私たちが提供する、いろんな [ユーザー事例](https://github.com/KMKfw/kmk_firmware/tree/master/user_keymaps)や[ドキュメント](https://github.com/KMKfw/kmk_firmware/tree/master/docs)からアイデアを得ることもできます。 - - -## ヘルプ/サポート -> Roads? Where we're going we don't need roads. - -デバッグについてのヘルプが必要な場合は[こちら](debugging.md)。 - -KMK についてサポートが必要な場合や、コミュニケーションをとりたい場合は[こちら](https://kmkfw.zulipchat.com)。 - -チャットで助けを求める場合やバグ レポートを開く場合は、可能であれば KMK -のコピーが最新であることを確認してください。 diff --git a/docs/ptBR/Getting_Started.md b/docs/ptBR/Getting_Started.md deleted file mode 100644 index e4979650d..000000000 --- a/docs/ptBR/Getting_Started.md +++ /dev/null @@ -1,125 +0,0 @@ -# Começando -> A vida era como uma caixa de chocolates. Você nunca saberia o que iria -> encontrar. - -KMK é uma camada focada em teclados que assenta-se em cima de -[CircuitPython](https://circuitpython.org/). Como tal, ela deve funcionar com a -maior parte das [placas que suportam -CircuitPython](https://circuitpython.org/downloads). É melhor usar a última -versão estável (>5.0). Dispositivos funcionais e recomendados podem ser -encontrados [aqui](Officially_Supported_Microcontrollers.md) - -Também fornecemos uma versão de CircuitPython otimizada para teclados -(simplificada para lidar com os limites de certas placas e com a seleção dos -módulos relevantes pré-instalados). Se você estiver se perguntando por que usar - - -## Guia Rápido -> Ao Infinito e Além! - -1. [Installe CircuitPython na tua - placa](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython). - Com a maioria das placas, deve ser algo tão fácil quanto copiar e colar o - firmware no drive. -2. Obtenha uma [cópia do - KMK](https://github.com/KMKfw/kmk_firmware/archive/refs/heads/master.zip) a - partir do ramo master. -3. Descompacte e cole o diretório KMK e o arquivo boot.py na raiz do drive USB - correspondente à tua placa (geralmente aparecendo como CIRCUITPY). -4. Crie um novo arquivo *code.py* ou *main.py* no mesmo diretório raiz (no - mesmo nível de boot.py) com o exemplo contido abaixo: - -***IMPORTANTE:*** adapte os pinos GP0 / GP1 para a tua placa específica! - -``` -print("Starting") - -import board - -from kmk.kmk_keyboard import KMKKeyboard -from kmk.keys import KC -from kmk.scanners import DiodeOrientation - -keyboard = KMKKeyboard() - -keyboard.col_pins = (board.GP0,) -keyboard.row_pins = (board.GP1,) -keyboard.diode_orientation = DiodeOrientation.COL2ROW - -keyboard.keymap = [ - [KC.A,] -] - -if __name__ == '__main__': - keyboard.go() -``` - -5. Usando um fio, um clipe de papel ou o que seja, conecte o GPIO 0 e o GPIO 1 - (ou os pinos que você escolheu para tua placa). - -6. Se ela imprimir um "A" (ou um "Q" ou o que depender do teu layout de - teclado), você conseguiu! - - - -## Agora que tudo está no seu lugar, você pode querer ir além... - -> Esta é tua última chance. Após isso Esta é sua última chance. Depois não há -> como voltar. Se tomar a pílula azul a história acaba, e você acordará na sua -> cama acreditando no que quiser. Se tomar a pílula vermelha ficará no País das -> Maravilhas e eu te mostrarei até onde vai a toca do coelho. Lembre-se: tudo o -> que estou te oferecendo é a verdade. Nada mais. - -### Você é extremamente sortudo e tem um teclado totalmente suportado - -Se seu teclado e micro-controlador são suportados oficialmente, simplesmente -visite a webpage com os seus arquivos e coloque-os na raiz do "flash drive". -Estas webpages podem ser vistas [aqui](https://github.com/KMKfw/boards). Você -precisará dos arquivos `kb.py` e `main.py`. Instruções mais avançadas podem ser -vistas [aqui](config_and_keymap.md). - -### Você obteve outro teclado, possivelmente artesanal, e quer customizar o KMK para ele - -Primeiro, certifique-se de entender como o seu teclado funciona, e em particular -sua configuração matricial específica. Você pode observar -[aqui](http://pcbheaven.com/wikipages/How_Key_Matrices_Works/) ou ler o -[guia](https://docs.qmk.fm/#/hand_wire) feito pelo time da QMK para teclados -artesanais. - -Uma vez que você compreendeu a essência da coisa: -- Você pode dar uma olhada [aqui](config_and_keymap.md) e [aqui](keys.md) para - começar a customizar seu arquivo code.py / main.py. -- Eis uma [referência](keycodes.md) dos códigos de teclas (*keycodes*) - disponíveis. -- A extensão [internacional](international.md) acrescenta teclas para layouts - não-americanos, e as [teclas de mídia](media_keys.md) acrecentam teclas - para... mídia. - -E para ir mais além: - -- [Sequências](sequences.md) são usadas para enviar múltiplas teclas em uma ação - só. -- [Camadas](layers.md) podem transformar totalmente como seu teclado age com um - simples toque. -- [HoldTap](holdtap.md) te permite customizar a maneira que uma tecla age quando é - pressionada ou "segurada"; e o -- [TapDance](tapdance.md) dependendo do número de vezes que ela é pressionada. - -Você quer extensões divertidas como RGB, teclados repartidos ao meio e mais? -Confira o que os [módulos](modules.md) e [extensões](extensions.md) podem -fazer! - -Você também pode obter ideias dos vários [exemplos de -usuários](https://github.com/KMKfw/kmk_firmware/tree/master/user_keymaps) que fornecemos e fuce nossa -[documentação](https://github.com/KMKfw/kmk_firmware/tree/master/docs). - - -## Ajuda e Suporte Adicionais -> Estradas? Para onde vamos, estradas são desnecessárias. - -Caso precise, ajuda para depuração pode ser encontrada [aqui](debugging.md). - -Se você precisa de suporte com o KMK ou quer somente dizer oi, encontre-nos no -canal [kmkfw no Zulip](https://kmkfw.zulipchat.com). -Se você precisa de ajuda ou pretende abrir um bug report, se -possível se possível, verifique se sua cópia do KMK está atualizada. diff --git a/docs/ptBR/Officially_Supported_Microcontrollers.md b/docs/ptBR/Officially_Supported_Microcontrollers.md deleted file mode 100644 index 7f3d7a7c2..000000000 --- a/docs/ptBR/Officially_Supported_Microcontrollers.md +++ /dev/null @@ -1,72 +0,0 @@ -# Micro-Controladores Oficialmente Suportados - -Enquanto a maioria dos dispositivos com Circuitpython são muito bons para -teclados artesanais, amaioria dos teclados é projetada para aceitar um Pro -Micro. As placas listadas abaixo ou são, ou podem ser adaptadas para essa -pinagem a fim de usar teclados comuns já presentes no mercado. - -## nice!nano - -Características: -- Pinagem Pro Micro -- Suporte a USB HID e Bluetooth -- Pode ser usado para teclados repartidos sem fio (Bluetooth) -- Suporte a bateria, incluindo carga - -Desvantagens: -- 25 dólares por micro-controladores na maioria das revendedoras - -Varejistas comund: -- [Boardsource](https://boardsource.xyz/store/5f4a1733bbaa5c635b83ed67) -- [Nice Keyboards](https://nicekeyboards.com/nice-nano/) - -## ItsyBitsy M4 Express - -Características: -- Preços acessíveis a partir de 15 dólares -- Pode rodar a maior parte das vantagens do KMK, incluindo RGB - -Desvantagens: -- Precisa de adaptadir para funcionar com a pinagem do Pro Micro. O adaptador - pode ser encontrado - [AQUI](https://github.com/KMKfw/kmk_firmware/tree/master/hardware) - -Varejistas Comuns: -- [Adafruit](https://www.adafruit.com/product/3800) - -## RP2040 - -Características: -- Preço bastante acessível -- Bastante poderosa dado o preço - -Desvantagens: -- Pouco suporte para kits de teclado - -Varejistas comuns: -- [Adafruit](https://www.adafruit.com/pico?src=raspberrypi) -- [SparkFun](https://www.sparkfun.com/products/17829?src=raspberrypi) - -## Adafruit ItsyBitsy nRF52840 Express - -Características: -- Suporte a USB HID e Bluetooth -- Mais acessível que o nice!nano, apenas 18 dólares - -Desvantagens: -- Precisa de adaptador para funcionar com teclados de pinagem Pro Micro pinout - keyboards. O adaptador pode ser encontrado - [AQUI](https://github.com/KMKfw/kmk_firmware/tree/master/hardware) -- O suporte à bateria precisa de uma placa adicional encontrada - [AQUI](https://www.adafruit.com/product/2124) - -Varejistas comuns: -- [Adafruit](https://www.adafruit.com/product/4481) - -## Outros Micro-Controladores - -O mínimo que você vai precisar: - -- CircuitPython/KMKpython -- 256KB de armazenamento flash -- HID sobre USB e/ou Bluetooth. diff --git a/docs/ptBR/adns9800.md b/docs/ptBR/adns9800.md deleted file mode 100644 index a880a8124..000000000 --- a/docs/ptBR/adns9800.md +++ /dev/null @@ -1,24 +0,0 @@ -# ADNS9800 - -Acrescente este módulo para controlar o sensor ótico ADNS9800. - - -```python -from kmk.modules.adns9800 import ADNS9800 -keyboard.modules.append(ADNS9800(cs=board.GP0, sclk=board.GP2, miso=board.GP4, mosi=board.GP3, invert_y=True)) -``` - -O firmware para este sensor deve ser obtido separadamente, e colocado em -`kmk\modules\adns9800_firmware.py`. - -```python -firmware = ( - b'\x03' - b'\xa6' - ... -) -``` - -## Parâmetros do Construtor - -ADNS9800(cs=*cs_pin*, sclk=*clock_pin*, miso=*miso_pin*, mosi=*mosi_pin*, invert_x=*False*, invert_y=*False*) diff --git a/docs/ptBR/ble_hid.md b/docs/ptBR/ble_hid.md deleted file mode 100644 index 42f890b17..000000000 --- a/docs/ptBR/ble_hid.md +++ /dev/null @@ -1,36 +0,0 @@ -# BLE HID - -Conexões Bluetooth ajudam a se livrar da maçaroca de fios! - -## Circuitpython - -Se não estiver usando, você precisará da biblioteca `adafruit_ble` -da Adafruit. Ela pode ser baixada -[aqui](https://github.com/adafruit/Adafruit_CircuitPython_BLE/tree/master/adafruit_ble). -Ela faz parte do [Pacotão Adafruit -CircuitPython](https://github.com/adafruit/Adafruit_CircuitPython_Bundle). Simplesmente -coloque-a na raiz do seu dispositivo circuitpython. Se não tiver certeza, é o -primeiro diretório com `main.py` nele, e deve ser o primeiro que você abre -quando acessa o dispositivo. - -## Habilitando BLE - -Para habilitar o BLE hid, modifique o `keyboard.go()`. Por padrão, o nome -exibido será o nome do "flash drive", o qual por padrão é CIRCUITPY: - -```python -if __name__ == '__main__': - keyboard.go(hid_type=HIDModes.BLE) -``` - -## Mudando o Nome Exibido - -Existem duas formas de mudar o nome exibido. O primeiro seria [mudando o nome do -do -drive](https://learn.adafruit.com/welcome-to-circuitpython/the-circuitpy-drive). O -segundo seria mudando `keyboard.go()` assim: - -```python -if __name__ == '__main__': - keyboard.go(hid_type=HIDModes.BLE, ble_name='KMKeyboard') -``` diff --git a/docs/ptBR/config_and_keymap.md b/docs/ptBR/config_and_keymap.md deleted file mode 100644 index 39e0ec0fa..000000000 --- a/docs/ptBR/config_and_keymap.md +++ /dev/null @@ -1,85 +0,0 @@ -# Configurando KMK - -KMK é configurado mediante uma enorme classe Python da velha guarda chamada -`KMKKeyboard`. Existem subclasses desta configuração que já vem com padrões -previamente preenchidos para diversos teclados conhecidos (por exemple, muitos -teclados QMK, TMK ou ZMK são suportados com um nice!nano, ou mediante nosso -adaptador de pinagem ItsyBitsy-para-ProMicro). Esta classe é a interface -principal entre usuários finais e os funcionamentos internos do KMK. Vamos -mergulhar! - -- Edite ou crie um arquivo chamado `main.py` em nosso drive `CIRCUITPY`. Você - também pode manter este arquivo em seu computador (possivelmente dentro de - `user_keymaps` - sinta-se livre para submeter um PR com suas definições de - layout!) e copie-o (seja manualmente, ou se você é adepto de ferramentas de - desenvolvimento e linha de comando, usando nosso - [Makefile](/docs/ptBR/flashing.md)). - Definitivamente é recomendado que você mantenha uma cópia extra de segurança - em algum lugar que não o micro-controlador - chips pifam, Circuitpython pode - ter problemas de corrupção. ou você pode estar em um dia ruim e apagar o - arquivo errado. - -- Atribuir uma instância `KMKKeyboard` a uma variável, por exemplo, `keyboard = - KMKKeyboard()` (note os parênteses). - -- Certificar-se quie esta instância de `KMKKeyboard` é realmente executada ao -fim do arquivo usando um bloco como este: - -```python -if __name__ == '__main__': - keyboard.go() -``` - -- Atribuir os pinos e a orientação do diodo (necessário apenas em teclados - artesanais), por exemplo: - -```python -import board - -from kmk.scanners import DiodeOrientation - -col_pins = (board.SCK, board.MOSI, board.MISO, board.RX, board.TX, board.D4) -row_pins = (board.D10, board.D11, board.D12, board.D13, board.D9, board.D6, board.D5, board.SCL) -rollover_cols_every_rows = 4 -diode_orientation = DiodeOrientation.COL2ROW -``` - -Os pinos devem ser baseados naquilo que o CircuitPython chama de pinos na sua -placa particular. Você pode encontrá-los na REPL do seu dispositivo -CircuitPython: - -```python -import board -print(dir(board)) -``` - -> Note: `rollover_cols_every_rows` só é suportado com -> `DiodeOrientation.COLUMNS`/`DiodeOrientation.COL2ROW`, não `DiodeOrientation.ROWS`/`DiodeOrientation.ROW2COL`. Este é usado em -> placas como a Planck Rev6 que reusa pinos de coluna para simular uma matriz -> 4x12 na forma de uma matriz 8x6. - -- Importe a lista global de definições com `from kmk.keys import KC`. Você pode - ou exibi-la no REPL como fizemos acima com `board`, ou simplesmente olhar na - nossa - [documentação](/docs/ptBR/keycodes.md). - Tentamos manter a lista razoavelmente atualizada, mas se tiver algo faltando, - você pode ter que ler o arquivo-fonte `kmk/keys.py` (e daí abrir um ticket - para nos avisar que os documentos estão desatualizados, ou mesmo abrir um PR - ajustando os documentos!) - -- Definir um keymap, que é, em termos Python, uma lista de listas de objetos - `Key`. Um keymap bem simples, para um teclado com apenas duas teclas físicas - em apenas uma camada, teria essa aparência: - -```python -keyboard.keymap = [[KC.A, KC.B]] -``` - -Você pode definir um monte de outras coisas - -- `keyboard.debug_enabled` que vai atirar um monte de informação de depuração - para o console serial. Raramente isso é necessário, mas pode fornecer - informação verdadeiramente valiosa se você precisa abrir um ticket. - -- `keyboard.tap_time` que define quanto tempo `KC.TT` e `KC.LT` vão esperar - antes de condiderar uma tecla "segurada" (veja `layers.md`). diff --git a/docs/ptBR/debugging.md b/docs/ptBR/debugging.md deleted file mode 100644 index 71e1a16c1..000000000 --- a/docs/ptBR/debugging.md +++ /dev/null @@ -1,16 +0,0 @@ -# Depuração - -A depuração liberará a maior parte do estado útil para o console. Isso pode ser -habilitado no seu firmware atribuindo esta configuração em seu teclado. **Note** -que isto o tornará mais lento, portanto habilite somente quando precisar depurar. - -```python -keyboard.debug_enabled = True -``` - -A saída pode ser vista conectando-se à porta serial do teclado. Remeta-se a -[este -documento](https://learn.adafruit.com/welcome-to-circuitpython/kattni-connecting-to-the-serial-console) -para mais informações sobre conectar-se à porta serial. Para usuários Linux, -recomendamos [picocom](https://github.com/npat-efault/picocom) ou -[screen](https://www.gnu.org/software/screen/manual/screen.html). diff --git a/docs/ptBR/encoder.md b/docs/ptBR/encoder.md deleted file mode 100644 index c325261c3..000000000 --- a/docs/ptBR/encoder.md +++ /dev/null @@ -1,64 +0,0 @@ -# Encoder - -Aumente o volume! Acrescente zoom, volume ou qualquer coisa do gênero ao seu -teclado! - -## Habilitando a Extensão - -O construtor toma no mínimo três argumentos: uma lista de pinos `pad_a`, uma -lista de pinos `pad_b`, e um `encoder_map`. O `encoder_map` é modelado de acordo -com o teclado e funciona da mesma forma. Ele deve ter tantas teclas qyanto seu -teclado, e usar teclas `KC.NO` para camadas que não exijam ação alguma. O -encoder suporta um modo de velocidade se você deseja fazer algo com edição de -áudio ou vídeo. A direção de incremento/decremento pode ser mudada a fim de -fazer par com a direção que o botão está orientado, atribuindo à flag `is_inverted`. - -## Configuração - -Eis um exemplo completo no `main.py` do Atreus62. - -Crie suas teclas especiais: - -```python -Zoom_in = KC.LCTRL(KC.EQUAL) -Zoom_out = KC.LCTRL(KC.MINUS) -``` - -Crie o `encoder_map`. - -Anatomia de uma tupla de `encoder_map`: `(increment_key, decrement_key, teclas -pressionadas por clique do encoder)` - -```python - -# create the encoder map, modeled after the keymap -encoder_map = [ - [ - # Only 1 encoder is being used, so only one tuple per layer is required - # Increment key is volume up, decrement key is volume down, and sends 2 - # key presses for every "click" felt while turning the encoder. - (KC.VOLU,KC.VOLD,2), - [ - # only one key press sent per encoder click - (Zoom_in, Zoom_out,1), - ], - [ - # No action keys sent here, the resolution is a dummy number, to be - # removed in the future. - (_______,_______,1),# - ] -] - -# create the encoder instance, and pass in a list of pad a pins, a lsit of pad b -# pins, and the encoder map created above -encoder = EncoderHandler([board.D40],[board.D41], encoder_map) - -# if desired, you can flip the incrfement/decrement direction of the knob by -# setting the is_inerted flag to True. If you turn the knob to the right and -# the volume goes down, setting this flag will make it go up. It's default -# setting is False -encoder.encoders[0].is_inverted = True - -# Make sure to add the encoder to the modules list -keyboard.modules = [encoder] -``` diff --git a/docs/ptBR/extensions.md b/docs/ptBR/extensions.md deleted file mode 100644 index 3974d657c..000000000 --- a/docs/ptBR/extensions.md +++ /dev/null @@ -1,19 +0,0 @@ -# Extensões - -Extensões acrescentam características que modificam a experiência, mas não as -características base do teclado. Elas são fornecidas para serem fáceis de -adicionar e de criar. Eles vivem numa *sandbox* que impede código ruim de -quebrar o teclado. - -## Extensões Base - -Estas extensões são fornecidas em todas as montagens e podem ser habilitadas. As -extensões fornecidas atualmente são: - -- [International](international.md): Acrescenta keycodes internacionais. -- [LED](led.md): Adiciona suporte a luz de fundo. Isto é para luz monocolorida, - não RGB. -- [MediaKeys](media_keys.md): Acrescenta suporte a teclas de mídia, como - controle de volume. -- [RGB](rgb.md): Iluminação brilhante RGB. Funcionará na maior parte das - matrizes RGB dado que é tratada como luz de brilho. diff --git a/docs/ptBR/flashing.md b/docs/ptBR/flashing.md deleted file mode 100644 index 1ccc3ebda..000000000 --- a/docs/ptBR/flashing.md +++ /dev/null @@ -1,40 +0,0 @@ -# Instruções para Gravação - -Em geral nós recomendamos seguir as instruções no `README.md`, porém, -majoritariamente como artefato de desenvolvimento, outro método de gravar o KMK -existe. Este método é testado e suportado apenas no Linux, porém ele deve -funcionar no MacOS, BSDs e outros Unix-likes. Pode ser que funcione também em -Cygwin e no Windows Subsystem for Linux. - -Dado que se tenham disponíveis o `make` e `rsync` no seu sistema (via `$PATH`), -o seguinte copiará a árvore `kmk` para seu dispositivo CircuitPython, bem como o -arquivo definido como `USER_KEYMAP` como seu `main.py`. Ele também copiará o -`boot.py`, que aloca um tamanho de pilha maior que o padrão do CircuitPython -(simplificando - mais RAM do seu dispositivo ficará disponível para o KMK e para -a configuração do seu teclado). Se qualquer destes arquivos já existir no seu -dispositivo CircuitPython, ele será sobrescrito sem aviso algum. - -Se você estiver tendo problemas com erros de permissão aqui, **não execute make -como root ou via sudo. Leia a seção a seguir sobre resolução de problemas. - -```sh -make MOUNTPOINT=/media/CIRCUITPY USER_KEYMAP=user_keymaps/nameofyourkeymap.py BOARD=board/nameofyourboard/kb.py -``` - -# Resolvendo Problemas - -## Linux/BSD - -Confira se seu drive foi montado em algum lugar mediante um aplicativo gráfico -ou algum sistema de auto-montagem. A maioria destas ferramentas monta os -dispositivos em pastas `/media` ou `/run/media`, provavelmente como -`/media/CIRCUITPY`. Se o dispositivo não está montado, você pode ler sobre como -montar um drive manualmente [na -ArchWiki](https://wiki.archlinux.org/index.php/File_systems#Mount_a_file_system). - -Por exemplo: - -`sudo mount -o uid=$(id -u),gid=$(id -g) /dev/disk/by-label/CIRCUITPY ~/mnt` - -Se você ainda está tendo algum problema, confira nossa página de suporte para -saber aonde você pode entrar em contato, e a comunidade irá te ajudar. diff --git a/docs/ptBR/handwiring.md b/docs/ptBR/handwiring.md deleted file mode 100644 index 9a304c734..000000000 --- a/docs/ptBR/handwiring.md +++ /dev/null @@ -1,8 +0,0 @@ -# Teclados Artesanais - -Este guia não irá comentar sobre teclados artesanais. Confira nossa lista de -[micro-controladores recomendados](Officially_Supported_Microcontrollers.md) e -siga o incrível guia sobre o assunto[aqui](https://docs.qmk.fm/#/hand_wire). -Este guia pode ser acompanhado até a parte de configurar o firmware. Depois de -configurar o teclado físico, você pode remeter a nosso guia de porte -[aqui](porting_to_kmk.md). diff --git a/docs/ptBR/holdtap.md b/docs/ptBR/holdtap.md deleted file mode 100644 index 5012594bf..000000000 --- a/docs/ptBR/holdtap.md +++ /dev/null @@ -1,27 +0,0 @@ -# Keycodes HoldTap - -Habilitar o HoldTap (adicionando-o à lista de módulos) te dará acesso aos -keycodes abaixo: - -```python -from kmk.modules.holdtap import HoldTap -keyboard.modules.append(HoldTap()) -``` - -## Keycodes - -| Novo Keycode | Descrição | -|--------------------------------------------------------|-----------------------------------------------------------------| -| LCTL = KC.HT(KC.SOMETHING, KC.LCTRL) | `LCTRL` se segurado `kc` se tocado | -| LSFT = KC.HT(KC.SOMETHING, KC.LSFT) | `LSHIFT` se segurado `kc` se tocado | -| LALT = KC.HT(KC.SOMETHING, KC.LALT) | `LALT` se segurado `kc` se tocado | -| LGUI = KC.HT(KC.SOMETHING, KC.LGUI) | `LGUI` se segurado `kc` se tocado | -| RCTL = KC.HT(KC.SOMETHING, KC.RCTRL) | `RCTRL` se segurado `kc` se tocado | -| RSFT = KC.HT(KC.SOMETHING, KC.RSFT) | `RSHIFT` se segurado `kc` se tocado | -| RALT = KC.HT(KC.SOMETHING, KC.RALT) | `RALT` se segurado `kc` se tocado | -| RGUI = KC.HT(KC.SOMETHING, KC.RGUI) | `RGUI` se segurado `kc` se tocado | -| SGUI = KC.HT(KC.SOMETHING, KC.LSHFT(KC.LGUI)) | `LSHIFT` e `LGUI` se segurado `kc` se tocado | -| LCA = KC.HT(KC.SOMETHING, KC.LCTRL(KC.LALT)) | `LCTRL` e `LALT` se segurado `kc` se tocado | -| LCAG = KC.HT(KC.SOMETHING, KC.LCTRL(KC.LALT(KC.LGUI))) | `LCTRL` e `LALT` e `LGUI` se segurado `kc` se tocado | -| MEH = KC.HT(KC.SOMETHING, KC.LCTRL(KC.LSFT(KC.LALT))) | `CTRL` e `LSHIFT` e `LALT` se segurado `kc` se tocado | -| HYPR = KC.HT(KC.SOMETHING, KC.HYPR) | `LCTRL` e `LSHIFT` e `LALT` e `LGUI` se segurado `kc` if tapped | diff --git a/docs/ptBR/international.md b/docs/ptBR/international.md deleted file mode 100644 index b57dad9d5..000000000 --- a/docs/ptBR/international.md +++ /dev/null @@ -1,34 +0,0 @@ -# Keycodes Internacionais - -A extensão internacional acrescenta teclas para teclados não-americanos. Ela -pode ser acrescentada à lista de exceções. - -```python -from kmk.extensions.international import International -keyboard.extensions.append(International()) -``` - -## Keycodes - -| Tecla | Alternativo | Descrição | -|-------------------|-------------|----------------------------------| -| `KC.NONUS_HASH` | `KC.NUHS` | Non-US `#` e `~` | -| `KC.NONUS_BSLASH` | `KC.NUBS` | Non-US `\` e | | -| `KC.INT1` | `KC.RO` | JIS `\` e | | -| `KC.INT2` | `KC.KANA` | JIS Katakana/Hiragana | -| `KC.INT3` | `KC.JYEN` | JIS `¥` | -| `KC.INT4` | `KC.HENK` | JIS Henkan | -| `KC.INT5` | `KC.MHEN` | JIS Muhenkan | -| `KC.INT6` | | JIS Numpad `,` | -| `KC.INT7` | | 7 Internacional | -| `KC.INT8` | | 8 Internacional | -| `KC.INT9` | | 9 Internacional | -| `KC.LANG1` | `KC.HAEN` | Hangul/English | -| `KC.LANG2` | `KC.HANJ` | Hanja | -| `KC.LANG3` | | JIS Katakana | -| `KC.LANG4` | | JIS Hiragana | -| `KC.LANG5` | | JIS Zenkaku/Hankaku | -| `KC.LANG6` | | Linguagem 6 | -| `KC.LANG7` | | Linguagem 7 | -| `KC.LANG8` | | Linguagem 8 | -| `KC.LANG9` | | Linguagem 9 | diff --git a/docs/ptBR/keycodes.md b/docs/ptBR/keycodes.md deleted file mode 100644 index d3b2f66a2..000000000 --- a/docs/ptBR/keycodes.md +++ /dev/null @@ -1,226 +0,0 @@ -# Visão Geral das Teclas - -## [Teclas Básicas] - -| Tecla | Alternativa | Descrição | -|-------------------------|----------------------|-----------------------------------------------| -| `KC.NO` | | Ignore esta tecla (NOOP) | -| `KC.TRANSPARENT` | `KC.TRNS` | Use a próxima tecla não transparente abaixo | -| `KC.A` | | `a` e `A` | -| `KC.B` | | `b` e `B` | -| `KC.C` | | `c` e `C` | -| `KC.D` | | `d` e `D` | -| `KC.E` | | `e` e `E` | -| `KC.F` | | `f` e `F` | -| `KC.G` | | `g` e `G` | -| `KC.H` | | `h` e `H` | -| `KC.I` | | `i` e `I` | -| `KC.J` | | `j` e `J` | -| `KC.K` | | `k` e `K` | -| `KC.L` | | `l` e `L` | -| `KC.M` | | `m` e `M` | -| `KC.N` | | `n` e `N` | -| `KC.O` | | `o` e `O` | -| `KC.P` | | `p` e `P` | -| `KC.Q` | | `q` e `Q` | -| `KC.R` | | `r` e `R` | -| `KC.S` | | `s` e `S` | -| `KC.T` | | `t` e `T` | -| `KC.U` | | `u` e `U` | -| `KC.V` | | `v` e `V` | -| `KC.W` | | `w` e `W` | -| `KC.X` | | `x` e `X` | -| `KC.Y` | | `y` e `Y` | -| `KC.Z` | | `z` e `Z` | -| `KC.N1` | | `1` e `!` | -| `KC.N2` | | `2` e `@` | -| `KC.N3` | | `3` e `#` | -| `KC.N4` | | `4` e `$` | -| `KC.N5` | | `5` e `%` | -| `KC.N6` | | `6` e `^` | -| `KC.N7` | | `7` e `&` | -| `KC.N8` | | `8` e `*` | -| `KC.N9` | | `9` e `(` | -| `KC.N0` | | `0` e `)` | -| `KC.ENTER` | `KC.ENT` | Return (Enter) | -| `KC.ESCAPE` | `KC.ESC` | Escape | -| `KC.BSPACE` | `KC.BSPC` | Backspace | -| `KC.TAB` | | Tab | -| `KC.SPACE` | `KC.SPC` | Barra de Espaço | -| `KC.MINUS` | `KC.MINS` | `-` e `_` | -| `KC.EQUAL` | `KC.EQL` | `=` e `+` | -| `KC.LBRACKET` | `KC.LBRC` | `[` e `{` | -| `KC.RBRACKET` | `KC.RBRC` | `]` e `}` | -| `KC.BSLASH` | `KC.BSLS` | `\` e | | -| `KC.SCOLON` | `KC.SCLN` | `;` e `:` | -| `KC.QUOTE` | `KC.QUOT` | `'` e `"` | -| `KC.GRAVE` | `KC.GRV`, `KC.ZKHK` | ` e `~`, JIS Zenkaku/Hankaku | -| `KC.COMMA` | `KC.COMM` | `,` e `<` | -| `KC.DOT` | | `.` e `>` | -| `KC.SLASH` | `KC.SLSH` | `/` e `?` | -| `KC.CAPSLOCK` | `KC.CLCK`, `KC.CAPS` | Caps Lock | -| `KC.F1` | | F1 | -| `KC.F2` | | F2 | -| `KC.F3` | | F3 | -| `KC.F4` | | F4 | -| `KC.F5` | | F5 | -| `KC.F6` | | F6 | -| `KC.F7` | | F7 | -| `KC.F8` | | F8 | -| `KC.F9` | | F9 | -| `KC.F10` | | F10 | -| `KC.F11` | | F11 | -| `KC.F12` | | F12 | -| `KC.PSCREEN` | `KC.PSCR` | Print Screen | -| `KC.SCROLLLOCK` | `KC.SLCK` | Scroll Lock | -| `KC.PAUSE` | `KC.PAUS`, `KC.BRK` | Pause | -| `KC.INSERT` | `KC.INS` | Insert | -| `KC.HOME` | | Home | -| `KC.PGUP` | | Page Up | -| `KC.DELETE` | `KC.DEL` | Delete | -| `KC.END` | | End | -| `KC.PGDOWN` | `KC.PGDN` | Page Down | -| `KC.RIGHT` | `KC.RGHT` | Seta para Direita | -| `KC.LEFT` | | Seta para Esquerda | -| `KC.DOWN` | | Seta para Baixo | -| `KC.UP` | | Seta para Cima | -| `KC.NUMLOCK` | `KC.NLCK` | Num Lock e Clear | -| `KC.KP_SLASH` | `KC.PSLS` | `/` Numérico | -| `KC.KP_ASTERISK` | `KC.PAST` | `*` Numérico | -| `KC.KP_MINUS` | `KC.PMNS` | `-` Numérico | -| `KC.KP_PLUS` | `KC.PPLS` | `+` Numérico | -| `KC.KP_ENTER` | `KC.PENT` | Enter Numérico | -| `KC.KP_1` | `KC.P1` | `1` Numérico e End | -| `KC.KP_2` | `KC.P2` | `2` Numérico e Seta para Baixo | -| `KC.KP_3` | `KC.P3` | `3` Numérico e Page Down | -| `KC.KP_4` | `KC.P4` | `4` Numérico e Seta para Esquerda | -| `KC.KP_5` | `KC.P5` | `5` | -| `KC.KP_6` | `KC.P6` | `6` Numérico e Seta para Direita | -| `KC.KP_7` | `KC.P7` | `7` Numérico e Home | -| `KC.KP_8` | `KC.P8` | `8` Numérico e Seta para Cima | -| `KC.KP_9` | `KC.P9` | `9` Numérico e Page Up | -| `KC.KP_0` | `KC.P0` | `0` Numérico e Insert | -| `KC.KP_DOT` | `KC.PDOT` | `.` Numérico e Delete | -| `KC.KP_EQUAL` | `KC.PEQL` | `=` | -| `KC.F13` | | F13 | -| `KC.F14` | | F14 | -| `KC.F15` | | F15 | -| `KC.F16` | | F16 | -| `KC.F17` | | F17 | -| `KC.F18` | | F18 | -| `KC.F19` | | F19 | -| `KC.F20` | | F20 | -| `KC.F21` | | F21 | -| `KC.F22` | | F22 | -| `KC.F23` | | F23 | -| `KC.F24` | | F24 | -| `KC.LOCKING_CAPS` | `KC.LCAP` | Caps Lock Travado | -| `KC.LOCKING_NUM` | `KC.LNUM` | Num Lock Travado | -| `KC.LOCKING_SCROLL` | `KC.LSCR` | Scroll Lock Travado | -| `KC.KP_COMMA` | `KC.PCMM` | `,` Numérico | -| `KC.KP_EQUAL_AS400` | | `=` Numérico em teclados AS/400 | -| `KC.LCTRL` | `KC.LCTL` | Left Control | -| `KC.LSHIFT` | `KC.LSFT` | Left Shift | -| `KC.LALT` | | Left Alt | -| `KC.LGUI` | `KC.LCMD`, `KC.LWIN` | Left GUI (Windows/Comme/Meta key) | -| `KC.RCTRL` | `KC.RCTL` | Right Control | -| `KC.RSHIFT` | `KC.RSFT` | Right Shift | -| `KC.RALT` | | Right Alt | -| `KC.RGUI` | `KC.RCMD`, `KC.RWIN` | Right GUI (Windows/Comme/Meta key) | - - -## [US ANSI Shift] - -| Tecla | Alternativa | Descrição | -|--------------------------|---------------------|---------------------| -| `KC.TILDE` | `KC.TILD` | `~` | -| `KC.EXCLAIM` | `KC.EXLM` | `!` | -| `KC.AT` | | `@` | -| `KC.HASH` | | `#` | -| `KC.DOLLAR` | `KC.DLR` | `$` | -| `KC.PERCENT` | `KC.PERC` | `%` | -| `KC.CIRCUMFLEX` | `KC.CIRC` | `^` | -| `KC.AMPERSE` | `KC.AMPR` | `&` | -| `KC.ASTERISK` | `KC.ASTR` | `*` | -| `KC.LEFT_PAREN` | `KC.LPRN` | `(` | -| `KC.RIGHT_PAREN` | `KC.RPRN` | `)` | -| `KC.UNDERSCORE` | `KC.UNDS` | `_` | -| `KC.PLUS` | | `+` | -| `KC.LEFT_CURLY_BRACE` | `KC.LCBR` | `{` | -| `KC.RIGHT_CURLY_BRACE` | `KC.RCBR` | `}` | -| `KC.PIPE` | | | | -| `KC.COLON` | `KC.COLN` | `:` | -| `KC.DOUBLE_QUOTE` | `KC.DQUO`, `KC.DQT` | `"` | -| `KC.LEFT_ANGLE_BRACKET` | `KC.LABK`, `KC.LT` | `<` | -| `KC.RIGHT_ANGLE_BRACKET` | `KC.RABK`, `KC.GT` | `>` | -| `KC.QUESTION` | `KC.QUES` | `?` | - -## [Teclas Internacionais] - -| Tecla | Alternativa | Descrição | -|-------------------|--------------------------------|-------------------------| -| `KC.NONUS_HASH` | `KC.NUHS` | ISO Direita de LSHIFT | -| `KC.NONUS_BSLASH` | `KC.NUBS` | ISO Esquerda de Return | -| `KC.APPLICATION` | `KC.APP`,`KC.SEL`,`KC.WINMENU` | Menu (próxima a RCTRL) | -| `KC.INT1` | `KC.RO` | | -| `KC.INT2` | `KC.KANA` | | -| `KC.INT3` | `KC.JYEN` | | -| `KC.INT4` | `KC.HENK` | | -| `KC.INT5` | `KC.MHEN` | | -| `KC.INT6` | | | -| `KC.INT7` | | | -| `KC.INT8` | | | -| `KC.INT9` | | | -| `KC.LANG1` | `HAEN` | | -| `KC.LANG2` | `HAEJ` | | -| `KC.LANG3` | | | -| `KC.LANG4` | | | -| `KC.LANG5` | | | -| `KC.LANG6` | | | -| `KC.LANG7` | | | -| `KC.LANG8` | | | -| `KC.LANG9` | | | - -## [Internal Keys] - -| Tecla | Descrição | -|-------------------------|-------------------------------------------------------------------------------------| -| `KC.RESET` | Reinicia o teclado | -| `KC.DEBUG` | Troca o estado de `debug_enabled`, habilitando o envio de log para o console serial | -| `KC.GESC` | Escape quando tocado, ` quando pressionado com Shift ou GUI | -| `KC.BKDL` | Backspace quando tocado, Delete quando pressionado com GUI | -| `KC.UC_MODE_NOOP` | Estabelece UnicodeMode para NOOP | -| `KC.UC_MODE_LINUX` | Estabelece UnicodeMode para Linux | -| `KC.UC_MODE_MACOS` | Estabelece UnicodeMode para MacOS | -| `KC.UC_MODE_WINC` | Estabelece UnicodeMode para WinCompose | -| `KC.MACRO_SLEEP_MS(ms)` | Dorme em uma macro. Confira MACROS para mais informação. | - - -## [Modifiers] - -| Tecla | Descrição | -|---------------|---------------------------------------| -| `KC.HYPR` | Segure Left Control, Shift, Alt e GUI | -| `KC.MEH` | Segure Left Control, Shift e Alt | -| `KC.LCTL(kc)` | Segure Left Control e aperte `kc` | -| `KC.LSFT(kc)` | Segure Left Shift e aperte `kc` | -| `KC.LALT(kc)` | Segure Left Alt e aperte `kc` | -| `KC.LGUI(kc)` | Segure Left GUI e aperte `kc` | -| `KC.RCTL(kc)` | Segure Right Control e aperte `kc` | -| `KC.RSFT(kc)` | Segure Right Shift e aperte `kc` | -| `KC.RALT(kc)` | Segure Right Alt e aperte `kc` | -| `KC.RGUI(kc)` | Segure Right GUI e aperte `kc` | - - -## [Teclas Bluetooth] - -| Tecla | Alternativa | Descrição | -|---------------------|-------------|-------------------------------------| -| `KC.BT_CLEAR_BONDS` | `KC.BT_CLR` | Limpa todas as ligações armazenadas | -| `KC.BT_NEXT_CONN` | `KC.BT_NXT` | Seleciona a conexão BT anterior | -| `KC.BT_PREV_CONN` | `KC.BT_PRV` | Seleciona a conexão BT seguinte | - - -# [Teclas de Mídia] - -Vejo [MediaKeys extensão](ptBR/media_keys.md). diff --git a/docs/ptBR/keys.md b/docs/ptBR/keys.md deleted file mode 100644 index 72fad83b7..000000000 --- a/docs/ptBR/keys.md +++ /dev/null @@ -1,168 +0,0 @@ -# Teclas - -> NOTE: Isto não é uma tabela de busca de objetos fornecidos pelo KMK. Esta -> listagem pode ser encontrada em `keycodes.md`. Possivelmente vale a pena -> observar o código-fonte bruto se você estiver travado: `kmk/keys.py`. - -Este é um montante de documentação sobre como teclas físicas são mapeada para -eventos (e o ciclo-de-vida destes eventos) no KMK. É um tanto técnico, mas se -você cogita estender a funcionalidade so seu teclado com código extra, você -precisará de pelo menos uma fração deste conhecimento técnico. - -Os primeiros passos neste processo não são tão interessantes para a maior parte -dos fluxos de trabalho, razão pela qual eles estão tão soterrados no KMK: -varremos um monte de faixas de GPIO (o quão rápido o CircuitPython nos permitir) -para ver onde, numa matriz de teclas, uma delas foi pressionada. Os detalhes -técnicos deste processo estão melhor descritos na -[Wikipedia](https://en.wikipedia.org/wiki/Keyboard_matrix_circuit). Então, -varremos o mapa de teclas definido, encontrando a primeira tecla válida neste -índice baseado na pilha de camadas ativas (esta lógica, se você quer ler o -código, está em `kmk/internal_state.py`, método `_find_key_in_map`). - -Os próximos passos são a parte interessante, mas para compreendê-los precisamos -entender um pouco do objeto `Key` (encontrado em `kmk/keys.py`). Objetos `Key` -têm algumas peças fundamentais de informação: - -* O `code`, que pode ser qualquer inteiro. Inteiros menores que - `FIRST_KMK_INTERNAL_KEY` são enviados pela pilha de HID (e portanto para o - computador, que traduzirá aquele inteiro para algo útil - por exemplo, - `code=4` torna-se `a` em um teclado US QWERTY/Dvorak) - -* Os modificadores anexados (para implementar coisas como Shift ou `KC.HYPR` que - são pressionamentos de teclas singulares enviadas juntamente a mais de uma - tecla em um único reporte HID. Este é um conceito diferente de Sequências, que - são uma característica do KMK documentada em `sequences.md`). Para todos os - propósitos fora do núcleo do KMK, este campo deve ser ignorado - ele pode ser - seguramente populado mediante meios bem mais sãos que perder tempo fazendo - isso na mão. - -* Alguns dados sobre se a tecla deveria ter sido pressionada ou liberada - isto - é majoritariamente um detalhe de implementação sobre como Sequências - funcionam, onde, por exemplo, `KC.RALT` pode precisar ser segurada por toda a - duração da sequência, em vez de ser liberada imediatamente antes de mover para - o próximo catactere. Geralmente usuários finais não precisam se preocupar com - isso, mas os campos são denominados `no_press` e `no_release` e são - referenciados em alguns lugares da base de código se você precisar de - exemplos. - -* Manipuladores (*handler*) para o pressionamento (algumas vezes chamado de - "keydown" ou "press") e liberação (algumas vezes chamado de "keyup" ou - "release"). KMK fornece manipuladores para funções padrão do yteclado e - algumas teclas especiais de sobrescrita (como `KC.GESC`, que é uma forma - aprimorada de teclas ANSI já existentes) em `kmk/handlers/stock.py`, para - troca de camadas em `kmk/handlers.layers.py`, e para tudo relacionado a - sequências (veja de novo `sequences.md`) em - `kmk/handlers/sequences.py`. Discutiremos mais estes em breve. - -* Chamadas de retorno (*callback*) opcionais a serem executadas antes e/ou - depois dos handlers acima. Mais sobre isso em breve. - -* Um campo `meta` genérico, que é mais comumente utilizado para teclas "com - argumentos" - objetos no objeto `KC` que na realidade são funções que retornam - instâncias de `Key`, que geralmente precisam acessar os argumentos passados - para a "função mais externa". Muitos destes exemplos são relacionados com - trocas de camadas - por exemplo, `KC.MO` é implementada como uma tecla com - argumentos - quando o usuário acrescenta `KC.MO(1)` ao teclado, a chamada de - função retorna um objeto `Key` com `meta` contendo um objeto contendo as - propriedades `layer` e `kc`. Existem outros usos para o campo `meta`, e - exemplos podem ser encontrados em `kmk/types.py`. - -Objetos `Key` também podem ser encadeados chamando eles! Para criar uma tecla -que segura Ctrl e Shift simultaneamente, simplesmente fazemos: - -```python -CTRLSHFT = KC.LCTL(KC.LSFT) - -keyboard.keymap = [ ... CTRLSHFT ... ] -``` - -Quando uma tecla é pressionada e tiramos um objeto `Key` do keymap, acontecerá o -seguinte: - -- Callbacks pré-pressionamento serão executados na ordem em que foram - atribuídos, com seus valores de retorno descartados (a não ser que o usuário - os anexe, eles quase nunca existem). -- O handler de pressionamento correspondente será executado (mais comumente este - é fornecido pelo KMK). -- Calllbacks pós-pressionamento serão executados na ordem em que foram - atribuídos, com seus valores de retorno descartados (a não ser que o usuário - os anexe, eles quase nunca existem). - -Os mesmos passos são executados quando uma tecla é liberada. - -_OK, então... Mas o que é um handler, e o que são esses callbacks?!_ - -Grosso modo, todos eles servem a um mesmo propósiti: fazer algo com os dados da -tecla, ou executar efeitos colaterais. A maioria dos handlers são fornecidos -pelo KMK internamente e modificam o `InternalState` de alguma forma - -adicionando a tecla à fila HID, modificando camadas, etc. Os handlers -pré/pós-pressionamento são projetados para permitir que a funcionalidade seja -embutida nestes pontos no fluxo de eventos sem ter que reimplementar (ou -importar e chamar internamente) os handlers internos. - -Todos esses métodos recebem os mesmos argumentos, e por isso eu vou copiar a -docstring direto do código-fonte: - -> Recebe o seguinte: -> -> - self (Esta instância Key) -> - state (InternalState corrente) -> - KC (A tabela de busca KC, para conveniência) -> - `coord_int` (Um inteiro, representação interna da coordenada da matriz para -> a tecla pressionada - costumeiramente isto não é útil para usuários finais, -> mas é fornecida por consistência com os manipuladores internos) -> - `coord_raw` (Uma tupla X,Y de coordenadas da matrix - costumeiramente não é -> útil, também) -> -> O valor de retorno do callback fornecido é descartado. _Exceções não são -> capturadas_, e provavelmente quebrarão o KMK se não forem tratadas dentro da -> tua função. -> -> Estes handlers são executados na ordem de anexação: handlers fornecidos por -> chamadas anteriores deste método são executados antes daqueles fornecidos por -> chamadas posteriores. - -Isto significa que se você quer adicionar coisas como suporte a LED/brilho, ou -um botão que aciona seu modem GSM para falar com alguém, ou seja lá o que você -puder fazer em CircuitPython, que também retenha as capacidades de troca de -camadas ou seja lá qual for o handler de suporte, você está coberto. Isto também -significa que você pode adicionar funcionalidades completamente novas ao KMK -escrevendo seu próprio handler. - -Eis um exemplo de gancho de ciclo de vida (*lifecycle hook*) que imprime um -Shrek gigante em Arte ASCII. Ele não utiliza os argumentos que recebe, porque -não tem intenção de modificar o estado interno. Ele é puramente um efeito -colateral ([side -effect](https://en.wikipedia.org/wiki/Side_effect_(computer_science))) executado -sempre que se pressiona o Alt esquerdo: - -```python -def shrek(*args, **kwargs): - print('⢀⡴⠑⡄⠀⠀⠀⠀⠀⠀⠀⣀⣀⣤⣤⣤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀') - print('⠸⡇⠀⠿⡀⠀⠀⠀⣀⡴⢿⣿⣿⣿⣿⣿⣿⣿⣷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀') - print('⠀⠀⠀⠀⠑⢄⣠⠾⠁⣀⣄⡈⠙⣿⣿⣿⣿⣿⣿⣿⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀') - print('⠀⠀⠀⠀⢀⡀⠁⠀⠀⠈⠙⠛⠂⠈⣿⣿⣿⣿⣿⠿⡿⢿⣆⠀⠀⠀⠀⠀⠀⠀') - print('⠀⠀⠀⢀⡾⣁⣀⠀⠴⠂⠙⣗⡀⠀⢻⣿⣿⠭⢤⣴⣦⣤⣹⠀⠀⠀⢀⢴⣶⣆') - print('⠀⠀⢀⣾⣿⣿⣿⣷⣮⣽⣾⣿⣥⣴⣿⣿⡿⢂⠔⢚⡿⢿⣿⣦⣴⣾⠁⠸⣼⡿') - print('⠀⢀⡞⠁⠙⠻⠿⠟⠉⠀⠛⢹⣿⣿⣿⣿⣿⣌⢤⣼⣿⣾⣿⡟⠉⠀⠀⠀⠀⠀') - print('⠀⣾⣷⣶⠇⠀⠀⣤⣄⣀⡀⠈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀') - print('⠀⠉⠈⠉⠀⠀⢦⡈⢻⣿⣿⣿⣶⣶⣶⣶⣤⣽⡹⣿⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀') - print('⠀⠀⠀⠀⠀⠀⠀⠉⠲⣽⡻⢿⣿⣿⣿⣿⣿⣿⣷⣜⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀') - print('⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣷⣶⣮⣭⣽⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀') - print('⠀⠀⠀⠀⠀⠀⣀⣀⣈⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⠀⠀⠀⠀⠀⠀') - print('⠀⠀⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠃⠀⠀⠀⠀⠀⠀⠀⠀') - print('⠀⠀⠀⠀⠀⠀⠀⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀') - print('⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠛⠻⠿⠿⠿⠿⠛⠉') - - -KC.LALT.before_press_handler(shrek) -``` - -Você também pode copiar uma tecla sem quaisquer handlers pré ou pós nela -mediante `.clone()`, tal que por exemplo, se eu já adicionei Shrek ao meu `LALT` -mas quero um `LALT` sem Shrek em algum lugar do keymap, eu posso simplesmente -clonar a tecla, e a nova tecla não terá meus handlers atrelados a ela: - -```python -SHREKLESS_ALT = KC.LALT.clone() -``` diff --git a/docs/ptBR/kmkpython_vs_circuitpython.md b/docs/ptBR/kmkpython_vs_circuitpython.md deleted file mode 100644 index 2ad0045a4..000000000 --- a/docs/ptBR/kmkpython_vs_circuitpython.md +++ /dev/null @@ -1,31 +0,0 @@ -## Comparação de Firmware - -### KMKPython - -KMKPython é um *fork* do Circuitpython, mas com bibliotecas para a maior parte -das extensões já embutidas. Isto te poupa de ter que reuni-las e atualizá-las -manualmente. Pode haver outras características adicionadas no futuro exclusivas -para o KMKPython. Para o nice!nano, o KMKPython é altamente recomendado e usado -em lugar do Circuitpython. - -#### Diferenças Notáveis - -- Bibliotecas embutidas para Bluetooth, RGB etc. -- Economiza espaço, pois os binários gerados são otimizados para teclados. -- micro-controladores como o nice!nano poderão acessar todas as vantagens - diretamente. - -### Circuitpython - -Circuitpython pode ser instalado seguindo [este -guia](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython). -É recomendável utilizar a versão mais recente, 5.0 ou superior. Versões beta -podem funcionar, mas espere suporte limitado. - -#### Diferenças Notáveis - -- Suporta mais dispositivos. -- Menos bibliotecas embutidas. Se precisar de RGB, Bluetooth e mais, você terá - que adicionar estas bibliotecas manualmente. -- Alguns dispositivos como o nice!nano não dispõem de muito espaço livre, então - nem todas as vantagens podem ser instaladas ao mesmo tempo. diff --git a/docs/ptBR/layers.md b/docs/ptBR/layers.md deleted file mode 100644 index b4a316771..000000000 --- a/docs/ptBR/layers.md +++ /dev/null @@ -1,23 +0,0 @@ -# Camadas - -O módulo de camadas acrescenta teclas para acessar outras camadas. Ele pode ser -acrescentado à lista de extensões. - - - -```python -from kmk.modules.layers import Layers -keyboard.modules.append(Layers()) -``` - -## Keycodes - -| Tecla | Descrição | -|---------------------|---------------------------------------------------------------------------| -| `KC.DF(layer)` | Troca a camada padrão | -| `KC.MO(layer)` | Ativa a camada momentaneamente, desativa quando solta | -| `KC.LM(layer, mod)` | Como `MO(layer)` ,as com `mod` ativo | -| `KC.LT(layer, kc)` | Ativa a camada momentaneamente se segurada, envia `kc` se tocada | -| `KC.TG(layer)` | Habilita a camada se estiver ativa, desativa caso contrário (*toggle*) | -| `KC.TO(layer)` | Ativa a camada, desativando todas as outras | -| `KC.TT(layer)` | Ativa a camada momentaneamente se segurada, troca se tocada repetidamente | diff --git a/docs/ptBR/led.md b/docs/ptBR/led.md deleted file mode 100644 index a5df0f36e..000000000 --- a/docs/ptBR/led.md +++ /dev/null @@ -1,47 +0,0 @@ -# LED (Luz de Fundo Monocor) - -Quer um teclado brilhante? Coloque algumas luzes! - -## Habilitando a Extensão - -Os únicos valores exigidos para a extensão LED são o pino de pixel e o número de -pixels/LEDs. Ao usar um teclado repartido, este número é referente a cada lado, -não ao total dos dois juntos. - -```python -from kmk.extensions.RGB import RGB -from kb import led_pin # This can be imported or defined manually - -led = LED(led_pin=led_pin) -keyboard.extensions.append(led) -``` - -## [Keycodes] - -| Tecla | Alternativa | Descrição | -|-----------------------|-------------|----------------------------------| -| `KC.LED_TOG` | | Muda o estado dos LEDs | -| `KC.LED_INC` | | Aumenta o brilho | -| `KC.LED_DEC` | | Diminui o brilho | -| `KC.LED_ANI` | | Aumenta a velocidade da animação | -| `KC.LED_AND` | | Diminui a velocidade da animação | -| `KC.LED_MODE_PLAIN` | `LED_M_P` | Led Estático | -| `KC.LED_MODE_BREATHE` | `LED_M_B` | Animação de respiração | - - -## Configuração - -Todos esses valores podem ser atribuídos por padrão quando o teclado inicia. - -```python -from kmk.extensions.led import AnimationModes -led = LED( - led_pin=led_pin, - brightness_step=5, - brightness_limit=100, - breathe_center=1.5, - animation_mode=AnimationModes.STATIC, - animation_speed=1, - val=100, - ) -``` diff --git a/docs/ptBR/media_keys.md b/docs/ptBR/media_keys.md deleted file mode 100644 index 20f408c04..000000000 --- a/docs/ptBR/media_keys.md +++ /dev/null @@ -1,26 +0,0 @@ -# Teclas de Mídia - -A extensão de teclas de mídia acrescenta teclas para controles comuns de -mídia. Ela pode ser adicionada à lista de extensões. - -```python -from kmk.extensions.media_keys import MediaKeys -keyboard.extensions.append(MediaKeys()) -``` - - ## Keycodes - -| Tecla | Alternativa | Descrição | -|-------------------------|-------------|--------------------------| -| `KC.AUDIO_MUTE` | `KC.MUTE` | Mudo | -| `KC.AUDIO_VOL_UP` | `KC.VOLU` | Aumenta o Volume | -| `KC.AUDIO_VOL_DOWN` | `KC.VOLD` | Aumenta o Volume | -| `KC.BRIGHTESS_UP` | `KC.BRIU` | Aumentar o brilho | -| `KC.BRIGHTNESS_DOWN` | `KC.BRID` | Diminuir o brilho | -| `KC.MEDIA_NEXT_TRACK` | `KC.MNXT` | Faixa Seguinte (Windows) | -| `KC.MEDIA_PREV_TRACK` | `KC.MPRV` | Faixa Anterior (Windows) | -| `KC.MEDIA_STOP` | `KC.MSTP` | Stop Faixa (Windows) | -| `KC.MEDIA_PLAY_PAUSE` | `KC.MPLY` | Tocar/Pausar Faixa | -| `KC.MEDIA_EJECT` | `KC.EJCT` | Ejetar (macOS) | -| `KC.MEDIA_FAST_FORWARD` | `KC.MFFD` | Faixa Seguinte (macOS) | -| `KC.MEDIA_REWIND` | `KC.MRWD` | Faixa Anterior (macOS) | diff --git a/docs/ptBR/modules.md b/docs/ptBR/modules.md deleted file mode 100644 index a4099fceb..000000000 --- a/docs/ptBR/modules.md +++ /dev/null @@ -1,18 +0,0 @@ -# Módulos - -Módulos, ao contrário de extensões, modificam como seu teclado funciona. Eles -são projetados para ter a capacidade de alterar o código-base de qualquer -maneira. Ao contrário de extensões, elas não ficam numa *sandbox*, e podem fazer -mudanças massivas à operação normal. - -## Módulos Principais - -Estes módulos são fornecidos em todas as montagens e podem ser habilitados. Os -módulos oferecidos correntemente são; - -- [Layers](layers.md): Acrescenta suporte a camadas (Tecla Fn) para permitir -colocar bem mais teclas no seu teclado. -- [HoldTap](holdtap.md): Acrescenta suporte para teclas modificadoras que agem -como teclas comuns ao serem tocadas, mas como modificadores quando seguradas. -- [Power](power.md): Economia de energia. Este é mais útil quando usando baterias. -- [Split](split_keyboards.md): Teclados repartidos em dois. Tão ergonômicos! diff --git a/docs/ptBR/mouse_keys.md b/docs/ptBR/mouse_keys.md deleted file mode 100644 index 58adb597a..000000000 --- a/docs/ptBR/mouse_keys.md +++ /dev/null @@ -1,23 +0,0 @@ -# Teclas de Mouse - -Para habilitar as teclas de mouse e/ou cursor para o teclado, adicione este -módulo à lista: - -```python -from kmk.modules.mouse_keys import MouseKeys -keyboard.modules.append(MouseKeys()) -``` - -# Keycodes - -| Keycode | Descrição | -|---------------------|------------------------------------------| -| `MB_LMB` | Botão esquerdo do mouse | -| `MB_RMB` | Botão direito do mouse | -| `MB_MMB` | Botão do meio do mouse | -| `MW_UP` | Rolar o scroll para cima | -| `MW_DOWN`, `MW_DN` | Rolar o scroll para baixo | -| `MS_UP` | Mover o cursor do mouse para cima | -| `MS_DOWN`, `MS_DN` | Mover o cursor do mouse para baixo | -| `MS_LEFT`, `MS_LT` | Mover o cursor do mouse para a esquerdax | -| `MS_RIGHT`, `MS_RT` | Mover o cursor do mouse para a direita | diff --git a/docs/ptBR/porting_to_kmk.md b/docs/ptBR/porting_to_kmk.md deleted file mode 100644 index 30166ac91..000000000 --- a/docs/ptBR/porting_to_kmk.md +++ /dev/null @@ -1,79 +0,0 @@ -# Portar para o KMK - -Portar uma placa para o KMK é bastante simples, e segue o seguinte formato-base: - -```python -import board - -from kmk.kmk_keyboard import KMKKeyboard as _KMKKeyboard -from kmk.scanners import DiodeOrientation -{EXTENSIONS_IMPORT} - -class KMKKeyboard(_KMKKeyboard): -{REQUIRED} - extensions = [] - -``` - -## REQUERIDO - -Isto é projetado para ser substituído com os pinos de definição de seu teclado. -Linhas, colunas e direção dos diodos (se houver) devem ser definidas dessa -forma: - -```python - row_pins = [board.p0_31, board.p0_29, board.p0_02, board.p1_15] - col_pins = [board.p0_22, board.p0_24, board.p1_00, board.p0_11, board.p1_04] - diode_orientation = DiodeOrientation.COL2ROW -``` - -## Pinos Adicionais para Extensões - -KMK inclui extensões embutidas para RGB e teclados repartidos, e para economia -de energia. Se estes são aplicáveis ao seu teclado/micro-controlador, os pinos -devem ser acrescentados aqui. Remeta às instruções na respectiva página de -extensões sobre como adicioná-los. Se não pretende adicionar extensões, mantenha -a lista vazia como mostrado. - -# Mapeamento Coordenado - -Se seu teclado não é eletricamente construído como um quadrado (apesar que a -maioria é), você pode fornecer o mapeamento diretamente. Um exemplo disso é o -teclado [Corne](https://github.com/foostan/crkbd). Ele tem 12 colunas para 3 -linhas, e 6 colunas para a linha inferior. Teclados repartidos são contados pelo -total, não por parte separada. Isto seria mais ou menos assim: - -```python -coord_mapping = [ - 0, 1, 2, 3, 4, 5, 24, 25, 26, 27, 28, 29, - 6, 7, 8, 9, 10, 11, 30, 31, 32, 33, 34, 35, -12, 13, 14, 15, 16, 17, 36, 37, 38, 39, 40, 41, - 21, 22, 23, 42, 43, 44, -] -``` - -## Keymaps - -Mapas de teclas (*keymap*) são organizados com listas de listas. Keycodes são -adicionados para cada tecla de cada camada. Veja [keycodes](keycodes.md) para -mais detalhes sobre que keycodes estão disponíveis. Se usar camadas ou outras -extensões, remeta também à página de extensões para keycodes adicionais. - -```python -from kb import KMKKeyboard -from kmk.keys import KC - -keyboard = KMKKeyboard() - -keyboard.keymap = [ - [KC.A, KC.B], - [KC.C, KC.D], -] - -if __name__ == '__main__': - keyboard.go() -``` - -## Mais Informação - -Mais informação pode ser vista [aqui](config_and_keymap.md) diff --git a/docs/ptBR/power.md b/docs/ptBR/power.md deleted file mode 100644 index 124e3676f..000000000 --- a/docs/ptBR/power.md +++ /dev/null @@ -1,48 +0,0 @@ -# Economia de Energia - -Este módulo permite economizar energia, e é voltado para teclados bluetooth/com -bateria. - -## Keycodes - -| Tecla | Descrição | -|--------------|----------------------------------| -| `KC.PS_TOG ` | Muda a economia ligado/desligado | -| `KC.PS_ON ` | Liga a economia | -| `KC.PS_OFF ` | Desliga a economia | - -# Habilitando a Extensão - -Para ligar a economia básica, isso é tudo o que é preciso: - -```python -from kmk.modules.power import Power - -power = Power() - -keyboard.modules.append(power) - -``` - -## Economia Extra Opcional - -Em placas com suporte, como a nice!nano, a energia pode ser cortada no VCC, -economizando energia extra se OLEDs ou RGBs estão instalados. Eles consomem -energia mesmo que estejam desligados, então isto os impede disso. - -```python -from kmk.modules.power import Power - -# Your kb.py may already have this set. If not, add it like this -# import board -# keyboard.powersave_pin = board.P0_13 -power = Power(powersave_pin=keyboard.powersave_pin) - -keyboard.modules.append(power) - -``` - -Certifique-se que o pino é o correto para seu micro-controlador. O exemplo dado -foi para o nice!nano. Nem todos os micro-controladores têm esta característica e -ela pode ser omitida se não houver, simplesmente haverá menos economia de -energia. diff --git a/docs/ptBR/rgb.md b/docs/ptBR/rgb.md deleted file mode 100644 index ea4a244ca..000000000 --- a/docs/ptBR/rgb.md +++ /dev/null @@ -1,171 +0,0 @@ -# RGB/Underglow/Neopixel - -Quer um teclado brilhante? Coloque alguma luz nele! - -## CircuitPython - -Se não estiver usando KMKpython, isto vai exigir a biblioteca neopixel da -Adafruit. Ela pode ser baixada -[aqui](https://github.com/adafruit/Adafruit_CircuitPython_NeoPixel/blob/6e35cd2b40575a20e2904b096508325cef4a71d3/neopixel.py). -É parte do [Pacotão Adafruit -CircuitPython](https://github.com/adafruit/Adafruit_CircuitPython_Bundle). Coloque-o -na raiz do seu dispositivo circuitpython. Se não souber qual é, é o diretório -com `main.py` nele, e deve ser o primeiro diretório que você vê ao abrir o dispositivo. - -Atualmente suportamos os LEDs endereçáveis a seguir: - - * WS2811, WS2812, WS2812B, WS2812C, etc. - * SK6812, SK6812MINI, SK6805 - -### Seleção de Cores - -KMK usa o sistema -[Hue-Saturation-Value](https://en.wikipedia.org/wiki/HSL_and_HSV) para -selecionar as cores, em vez do RGB. A roda de cores abaixo demonstra seu -funcionamento. - -- Mudar o **Hue** dá a volta no círculo. -- Mudar o **Saturation** move entre as seções internas e externas do círculo, -afetando a intensidade da cor. -- Mudar o **Value** atribui o valor do brilho total. - -## Habilitando a Extensão - -Os únicos valores exigidos para a extensão RGB devem ser o pino de pixel e o -número de pixels/LEDs. Se estiver usando um teclado repartido, este número é por -parte, não pelo total das duas. - -```python -from kmk.extensions.RGB import RGB -from kb import rgb_pixel_pin # This can be imported or defined manually - -rgb = RGB(pixel_pin=rgb_pixel_pin, num_pixels=27) -keyboard.extensions.append(rgb) -``` - -## [Keycodes] - -| Key | Aliases | Descrição | -|-------------------------------|------------|-----------------------------------------| -| `KC.RGB_TOG` | | Liga/desliga o RGB | -| `KC.RGB_HUI` | | Aumenta Hue | -| `KC.RGB_HUD` | | Diminui Hue | -| `KC.RGB_SAI` | | Aumenta Saturation | -| `KC.RGB_SAD` | | Diminui Saturation | -| `KC.RGB_VAI` | | Aumenta Value | -| `KC.RGB_VAD` | | Diminui Value | -| `KC.RGB_ANI` | | Aumenta a velocidade da animação | -| `KC.RGB_AND` | | Diminui a velocidade da animação | -| `KC.RGB_MODE_PLAIN` | `RGB_M_P` | RGB Estático | -| `KC.RGB_MODE_BREATHE` | `RGB_M_B` | Animação de Respiração | -| `KC.RGB_MODE_RAINBOW` | `RGB_M_R` | Animação de Arco-Íris | -| `KC.RGB_MODE_BREATHE_RAINBOW` | `RGB_M_BR` | Animação de Arco-Íris Respirando | -| `KC.RGB_MODE_KNIGHT` | `RGB_M_K` | Animação de SuperMáquina (Knight Rider) | -| `KC.RGB_MODE_SWIRL` | `RGB_M_S` | Animação de Redemoinho | - -## Configuração - -| Definição | Padrão | Descrição | -|--------------------------------------|-------------|-----------------------------------------------------------------------| -| `keyboard.pixel_pin` | | O pino conectado ao pino de dados dos LEDs | -| `keyboard.num_pixels` | | O número de LEDs conectados | -| `keyboard.rgb_config['rgb_order']` | `(1, 0, 2)` | A ordem dos pixels RGB, e opcionalmente branco. Exemplo: (1, 0, 2, 3) | -| `keyboard.rgb_config['hue_step']` | `10` | O número de passos para ciclar ao longo do Hue | -| `keyboard.rgb_config['sat_step']` | `17` | O número de passos para mudar a Saturation | -| `keyboard.rgb_config['val_step']` | `17` | O número de passos para mudar o Value (brilho) | -| `keyboard.rgb_config['hue_default']` | `0` | Hue padrão quando o teclado inicia | -| `keyboard.rgb_config['sat_default']` | `100` | Saturation padrão quando o teclado inicia | -| `keyboard.rgb_config['val_default']` | `100` | Value padrão (brilho) quando o teclado inicia | -| `keyboard.rgb_config['val_limit']` | `255` | Nível máximo de brilho | - -## Configuração da Animação Embutida - -| Definição | Padrão | Descrição | -|-----------------------------------------------|--------|-----------------------------------------------------------------------------------------------| -| `keyboard.rgb_config['breathe_center']` | `1.5` | Usado para calcular a curva da animação de respiração. Qualquer valor em 1.0-2.7 é válido. | -| `keyboard.rgb_config['knight_effect_length']` | `4` | O número de LEDs a ligar para a animação do KITT (SuperMáquina) | - -## Funções - -Se você quer criar suas próprias animações, ou por exemplo mudar a luminosidade -numa macro, ou numa troca de camadas, eis algumas funções disponíveis: - -| Function | Descrição | -|-------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------| -| `keyboard.pixels.set_hsv_fill(hue, sat, val)` | Preenche todos os LEDs com valores HSV | -| `keyboard.pixels.set_hsv(hue, sat, val, index)` | Atribui um valor HSV a um LED específico | -| `keyboard.pixels.set_rgb_fill((r, g, b))` | Preenche todos os LEDs com valores RGB(W) | -| `keyboard.pixels.set_rgb((r, g, b), index)` | Atribui um valor RGB(W) a um LED específico | -| `keyboard.pixels.disable_auto_write(bool)` | Quando `True`, desabilita mostrar as mudanças. Bom para atribuir múltiplas mudanças de LEDs antes de uma atualização visível | -| `keyboard.pixels.increase_hue(step)` | Aumenta Hue de um `step` dado | -| `keyboard.pixels.decrease_hue(step)` | Diminui Hue de um `step` dado | -| `keyboard.pixels.increase_sat(step)` | Aumenta Saturation de um `step` dado | -| `keyboard.pixels.decrease_sat(step)` | Diminui Saturation de um `step` dado | -| `keyboard.pixels.increase_val(step)` | Aumenta Value (brilho) de um `step` dado | -| `keyboard.pixels.decrease_val(step)` | Diminui Value (brilho) de um `step` dado | -| `keyboard.pixels.increase_ani()` | Aumenta a velocidade da animação de 1. Máximo 10 | -| `keyboard.pixels.decrease_ani()` | Diminui a velocidade da animação de 1. Mínimo 10 | -| `keyboard.pixels.off()` | Desliga todos os LEDs | -| `keyboard.pixels.show()` | Exibe todas as configurações armazenadas para os LEDs. Útil quando `disable_auto_write` explicado abaixo | -| `keyboard.pixels.time_ms()` | Retorna um tempo em milissegundos desde que o teclado foi ligado. Útil para temporizadores de início/parada | - - -## Acesso Direto às Variáveis - -| Definição | Padrão | Descrição | -|-------------------------------------|----------|----------------------------------------------------------------------------------------------------------------------------------------| -| `keyboard.pixels.hue` | `0` | Atribui à Hue, 0-360 | -| `keyboard.pixels.sat` | `100` | Atribui à Saturation, 0-100 | -| `keyboard.pixels.val` | `80` | Atribui ao Brightness, 1-255 | -| `keyboard.pixels.reverse_animation` | `False` | Se `True`, algumas animações vão rodar ao contrário. Pode ser usado seguramente em animações do usuário | -| `keyboard.pixels.animation_mode` | `static` | Isto pode ser modificado para quaisquer modos inclusos, ou para algo customizado para interações do usuário. Qualquer string é válida. | -| `keyboard.pixels.animation_speed` | `1` | Aumenta a velocidade da animação na maior parte das animações. Recomendado 1-5, máximo 10. | - -```python -from kmk.extensions.rgb import AnimationModes -rgb = RGB(pixel_pin=rgb_pixel_pin, - num_pixels=27 - num_pixels=0, - val_limit=100, - hue_default=0, - sat_default=100, - rgb_order=(1, 0, 2), # GRB WS2812 - val_default=100, - hue_step=5, - sat_step=5, - val_step=5, - animation_speed=1, - breathe_center=1, # 1.0-2.7 - knight_effect_length=3, - animation_mode=AnimationModes.STATIC, - reverse_animation=False, - ) -``` - -## Modificação do Hardware - -Para incluir LEDS em placas que não têm suporte nativo, você terá que -acrescentar três fios. O de força correm nos pinos de 3.3V ou 5V (dependendo do -LED), pinos de terra e dados precisarão ser adicionados a um pino não usado em -seu micro-controlador a não ser que seu teclado tenha pontos de soldagem -específicos para eles. Com estes três fios conectados, atribua ao `pixel_pin` -como descrito acima, e você está pronto para usar seus RGB LED's/Neopixels. - -## Consertando os Problemas - -### Cores Incorretas - -Se as cores estão erradas, confira a ordem dos pixels nos seus LEDs -específicos. Eis alguns comuns. - -* WS2811, WS2812, WS2812B, WS2812C são todos GRB (1, 0, 2) -* SK6812, SK6812MINI, SK6805 são todos GRB (1, 0, 2) -* Neopixels variam dependendo de onde você compra. Isto vem informado na página - do produto. - -### Luzes não ligam - -Certifique-se de que sua placa suporta luz de fundo de LED, conferindo por uma -linha com `PIXEL_PIN`. Se não tiver, você pode adicionar ao seu keymap. Se você -adicionou os LEDs por conta própria, você também precisa atribuir a `num_pixels` -o número total de LEDs instalados. diff --git a/docs/ptBR/sequences.md b/docs/ptBR/sequences.md deleted file mode 100644 index 0ce96f30b..000000000 --- a/docs/ptBR/sequences.md +++ /dev/null @@ -1,93 +0,0 @@ -# Sequências - -Sequências são usadas para enviar múltiplos pressionamentos de teclas em uma -única ação, e pode ser usado para coisas como caracteres Unicode (até mesmo -emojis! 🇨🇦), geradores lorei epsum, disparo de efeitos colaterais (pense em -iluminação, apitos, mineradores de criptomoedas otimizados para -micro-controladores, etc.). Se você ainda não tem certeza do que é isso, a -maioria dos fornecedores chama estes de "Macros", mas pode fazer muito mais se -você quiser. - -## Enviar Strings - -A sequência mais básica é `send_string`. Ela pode ser usada para enviar qualquer -caractere do alfabeto inglês, e um conjunto de outras teclas "padrão" (Enter, -espaço, ponto de exclamação, etc.) - -```python -from kmk.handlers.sequences import send_string - -WOW = send_string("Wow, KMK is awesome!") - -keyboard.keymap = [, WOW, ] -``` - -## Unicode - -Antes de tentar enviar sequências de Unicode, certifique-se que você habilite o -seu `UnicodeMode`. Você pode atribuir um valor inicial no seu keymap pela -variável `keyboard.unicode_mode`. - -São fornecidas teclas para mudar este modo em tempo de execução - por exemplo, -`KC.UC_MODE_LINUX`. - -### Modos Unicode - -No Linux, Unicode usa `Ctrl-Shift-U`, suportado pelo `ibus` e GTK+3. Usuários de -`ibus` precisarão acrescentar `IBUS_ENABLE_CTRL_SHIFT_U=1` aos seus ambientes -(`~/profile`, `~/.bashrc`, `~/.zshrc`, ou o configurador do seu desktop). - -No Windows, é necessário usar o -[WinCompose](https://github.com/samhocevar/wincompose). - -- Linux : `UnicodeMode.LINUX` ou `UnicodeMode.IBUS`. -- Mac: `UnicodeMode.MACOS` ou `UnicodeMode.OSX` ou `UnicodeMode.RALT`. -- Windows: `UnicodeMode.WINC`. - - -### Exemplos Unicode - -Para enviar um símbolo Unicode: - -```python -from kmk.handlers.sequences import unicode_string_sequence - -FLIP = unicode_string_sequence('(ノಠ痊ಠ)ノ彡┻━┻') - -keyboard.keymap = [, FLIP, ] -``` - -Se, em vez disso, você manter uma tabela de busca de suas sequências (talvez -para atrelar emojis às teclas), isto também é suportado, mediante um processo -extremamente prolixo: - -```python -from kmk.handlers.sequences import compile_unicode_string_sequences as cuss - -emoticons = cuss({ - 'BEER': r'🍺', - 'HAND_WAVE': r'👋', -}) - -keymap = [, emoticons.BEER, emoticons.HAND_WAVE, ] -``` - -> Um observador notará que a notação-de-ponto (*dot notation*) é suportada aqui, -> apesar de preencher um dicionário - o retorno de -> `compile_unicode_string_sequences` é um `kmk.types.AttrDict`, que você pode -> entender como uma visão somente-leitura sobre um dicionário acrescentando -> acesso baseado em atributos (*dot notation*). - -Finalmente, se você precisa enviar pontos-de-código Unicode em modo bruto, isto -é suportado também, mediante `unicode_codepoint_sequence`. - -```python -from kmk.handlers.sequences import unicode_codepoint_sequence - -TABLE_FLIP = unicode_codepoint_sequence([ - "28", "30ce", "ca0", "75ca","ca0", "29", - "30ce", "5f61", "253b", "2501", "253b", -]) - -keyboard.keymap = [, TABLE_FLIP, ] -``` diff --git a/docs/ptBR/split_keyboards.md b/docs/ptBR/split_keyboards.md deleted file mode 100644 index b5f7fd5ae..000000000 --- a/docs/ptBR/split_keyboards.md +++ /dev/null @@ -1,77 +0,0 @@ -# Teclados Repartidos - -Teclados repartidos são quase a mesma coisa que os inteiriços. UART com fio é -totalmente suportada, e os teclados repartidos com Bluetooth estão em fase de -teste, porém não oferecemos suporte a eles atualmente. - -## UART com Fio - -Conexões com fio podem usar UART com um ou dois fios. Com dois, você poderá -sincronizar as partes, o que habilita características adicionais em algumas -extensões. - -```python -from kb import data_pin -:from kmk.modules.split import Split, SplitType - -split = Split(split_side=SplitSide.LEFT) -keyboard.modules.append(split) -``` - -## Bluetooth (no TRRS) [Atualmente em fase de testes] - -Repartidos sem fio são completamente providos de comunicação de via dupla, -permitindo que todas as extensões fuincionem 100%. - -```python -from kb import data_pin -from kmk.modules.split import Split, SplitType, Split_Side - - -split = Split(split_type=Split.BLE, split_side=SplitSide.LEFT) -OR -split = Split(split_type=Split.BLE, split_side=SplitSide.LEFT) -keyboard.modules.append(split) -``` - -### Configuração - -Opções úteis de configuração: - -```python -split = Split( - split_flip=True, # If both halves are the same, but flipped, set this True - split_side=None, # Sets if this is to SplitSide.LEFT or SplitSide.RIGHT, or use EE hands - split_type=SplitType.UART, # Defaults to UART - split_target_left=True, # If you want the right to be the target, change this to false - uart_interval=20, # Sets the uarts delay. Lower numbers draw more power - data_pin=None, # The primary data pin to talk to the secondary device with - data_pin2=None, # Second uart pin to allow 2 way communication - target_left=True, # Assumes that left will be the one on USB. Set to folse if it will be the right - uart_flip=True, # Reverses the RX and TX pins if both are provided -) - -``` - -### EE HANDS - -Se você quer plugar USB em qualquer dos dois lados, ou usa Bluetooth, esta é -para você. - -Renomeie seu drive CIRCUITPY para alguma coisa diferente. O lado esquerdo deve -terminar em L (de *left*) e o direito em R (de *right*). O nome deve ter 11 -caracteres ou menos! Esta é uma limitação do sistema de arquivos. (Por exemplo, -NYQUISTL para o lado esquerdo e NYQUISTR para o direito.) Se você escolher um -nome com mais de 11 caracteres, irá receber um erro. Instruções sobre como fazer -isso estão -[aqui](https://learn.adafruit.com/welcome-to-circuitpython/the-circuitpy-drive). - -Para conexões com fio, você não precisa ajustar nada. Para Bluetooth, remova o -`split_side` assim: - -```python -# Wired -split = Split() -# Wireless -split = Split(split_type=Split.BLE) -``` diff --git a/docs/ptBR/support.md b/docs/ptBR/support.md deleted file mode 100644 index 5b52124f8..000000000 --- a/docs/ptBR/support.md +++ /dev/null @@ -1,7 +0,0 @@ -# Suporte - -Se você precisa de suporte com o KMK ou quer somente dizer oi, encontre-nos no -canal [no Zulip](https://kmkfw.zulipchat.com). - -Se você precisa de ajuda ou pretende abrir um bug report, se -possível se possível, verifique se sua cópia do KMK está atualizada. diff --git a/docs/ptBR/tapdance.md b/docs/ptBR/tapdance.md deleted file mode 100644 index be8fb69d6..000000000 --- a/docs/ptBR/tapdance.md +++ /dev/null @@ -1,59 +0,0 @@ -# Tapdance - -Tapdance é uma forma de permitir que uma tecla física funcione como teclas/ações -lógicas múltiplas sem usar camadas. Com tapdance básico, você pode disparar -estas macros ou teclas "aninhadas" mediante uma série de toques (*taps*) da -tecla física dentro de um tempo limite dado. - -A ação "lógica" resultante funciona como qualquer outra tecla - ela pode ser -pressionada e liberada imediatamente, ou pode ser segurada. Por exemplo, tomemos -a tecla `KC.TD(KC.A, KC.B)`. Se a tecla de tapdance é pressionada e liberada -rapidamente, a letra "a" é enviada. Se é tocada e liberada duas vezes -rapidamente, a letra "b" será enviada. Se é tocada e segurada uma vez, a letra -"a" será segurada até que a tecla de tapdance seja liberada. Se é tocada e -liberada uma vez rapidamente, e daí tocada e segurada (ambas as ações dentro do -tempo limite), a letra "b" será mantida até que a tecla de tapdance seja -liberada. - -Para usar isso, você pode desejar definir um valor para `tap_time` na -configuração de seu teclado. Este valor é um inteiro indicando o tempo em -milissegundos, e seu valor padrão é `300`. - -Você pode então desejar criar uma sequência de teclas usando -`KC.TD(KC.SOMETHING, KC.SOMETHING_ELSE, MAYBE_THIS_IS_A_MACRO, WHATEVER_YO)`, e -colocar em algum lugar. Os únicos limites em quantas teclas pode haver numa -sequência são, teoricamente, o montante de memória RAM na sua -microcontroladora/placa, e quão rápido você pode pressionar a tecla física. Eis -a sua chance de usar toda sua experiência de anos e anos estraçalhando o botão -nos videogames. - -**NOTE**: Correntemente nossa implementação de tapdance têm algumas limitações, -as quais pretendemos consertar "eventualmente", mas por ora é bom notar: - -- O comportamento de troca momentânea de camadas em uma sequência de tapdance é - atualmente "indefinido" na melhor hipótese, e provavelmente vai quebrar seu - teclado. Por ora, recomendamos fortemente evitar `KC.MO`, bem como qualquer - outra tecla de modificação de camada que use comportamento de troca - momentânea - `KC.LM`, `KC.LT`, and `KC.TT`. - -Eis um exemplo de tudo isso em ação: - -```python -from kmk.keycodes import KC -from kmk.macros.simple import send_string - -keyboard = KMKKeyboard() - -keyboard.tap_time = 750 - -EXAMPLE_TD = KC.TD( - KC.A, # Tap once for "a" - KC.B, # Tap twice for "b" - # Tap three times to send a raw string via macro - send_string('macros in a tap dance? I think yes'), - # Tap four times to toggle layer index 1 - KC.TG(1), -) - -keyboard.keymap = [[ ...., EXAMPLE_TD, ....], ....] -```