Matriz de teclado de prototipagem de 64 teclas para Arduino

Componentes e suprimentos

Arduino UNO

1N4148 - Troca rápida para fins gerais

Interruptor tátil, acionado pela parte superior

Fixar cabeçalhos

74HC595 Shift Register

Ferramentas e máquinas necessárias

Ferro de soldar (genérico)

Aplicativos e serviços online

Arduino IDE

Sobre este projeto

Atualização:eu melhorei o código, consulte "Atualizar" no final.

Atualmente estou trabalhando em um projeto que terá um teclado integrado, que apresentou um problema:como faço para incluir um teclado no protótipo da placa de desenvolvimento? Não posso usar um teclado USB ou um teclado existente com base em Arduino, porque o teclado no projeto real está conectado diretamente ao microcontrolador que lida com todas as outras funções. Portanto, projetei esta matriz de teclado de prototipagem de 64 teclas com base em PCB.

Este PCB não contém ICs (circuitos integrados). As linhas e colunas da matriz do teclado são conectadas diretamente aos cabeçalhos dos pinos para que o teclado possa ser conectado a um Arduino ou qualquer outro microcontrolador. É perfeito para prototipar seus projetos que incluirão um teclado integrado.

Incluí código detalhado com muitos comentários para fazer isso funcionar com qualquer placa de desenvolvimento compatível com o Arduino que tenha pinos de I / O suficientes disponíveis - são necessários 11 pinos. O teclado tem 64 teclas, incluindo modificadores para shift, maiúsculas, ctrl, alt, fn e "especial". Existem também seis teclas adicionais que podem ser usadas para o que você quiser. As funções de cada tecla podem ser definidas individualmente, incluindo a função de cada tecla quando um modificador está ativo. Na minha opinião, isso é significativamente mais útil do que o código de teclado existente que limita severamente sua capacidade de personalizar o comportamento das teclas.

O código fornecido imprimirá texto em Serial. Isso pode ser facilmente alterado se você quiser que o texto vá para outro lugar.

Uma observação sobre o tamanho do programa:

O código que forneço é muito grande, porque não utiliza nenhuma biblioteca existente. Escrevi este código totalmente do zero para permitir a personalização que eu solicitei. Em um Arduino UNO, isso usará 9100 bytes (28%) do espaço de armazenamento do programa e as variáveis globais usarão 394 bytes (19%) da memória dinâmica.

Meu código provavelmente poderia ser mais eficiente e suas bibliotecas e esboços para teclados certamente são menores, mas esta é a única maneira que eu poderia imaginar para fornecer flexibilidade completa sobre cada tecla com cada modificador. Ele também leva em consideração o uso do teclado no mundo real. Por exemplo, com meu código pressionando a tecla Shift enquanto Caps Lock está habilitado resultará em uma letra minúscula como deveria. Por padrão, manter pressionada a tecla FN enquanto pressiona ESC não fará nada. Mas esse comportamento é totalmente personalizável, então você pode alterá-lo como quiser.

Suprimentos:

O PCB personalizado
Botões tácteis momentâneos de 6x6x5mm (x64)
1N4148 diodos de comutação (x64)
cabeçalhos de pino 1x8, feminino ou masculino (x2)
74HC595 registrador de deslocamento
Jumper fios
Placa de ensaio
Arduino Uno ou qualquer placa de desenvolvimento de microcontrolador compatível com Arduino

Etapa 1:Como funciona uma matriz de teclado

Por que uma matriz de teclado é necessária?

Este teclado possui 64 teclas. Se você fosse conectar cada um desses botões diretamente à sua placa de desenvolvimento, precisaria de 64 pinos de E / S. Isso é muito de pinos e mais do que a maioria das placas de desenvolvimento tem disponível. Para reduzir a um número muito mais razoável, podemos usar uma matriz de teclado, que requer apenas um número de pinos igual à raiz quadrada (arredondado para cima) do número de teclas.

Uma matriz de teclado é configurada para que cada chave seletora em uma fileira seja conectada e cada chave seletora em uma coluna seja conectada. Quando queremos ver quais teclas estão pressionadas, "ativamos" a primeira linha e verificamos cada coluna. Se uma determinada coluna estiver ativa, sabemos que a tecla nessa coluna e linha 1 foi pressionada. Em seguida, desativamos a linha 1 e ativamos a linha 2 e, em seguida, verificamos todas as colunas novamente. Depois que todas as linhas foram ativadas, simplesmente recomeçamos na primeira linha.

Como examinamos a matriz do teclado:

Como estamos trabalhando com um microcontrolador, "ativar" significa definir essa linha como LOW ou HIGH. Neste caso, estamos definindo a linha como BAIXA porque estamos usando os resistores pullup integrados do microcontrolador em nossos pinos de entrada de coluna. Sem um resistor pullup ou pull-down, um pino de entrada reagirá de forma imprevisível como resultado da interface, o que registrará pressionamentos de botão falsos.

O microcontrolador ATmega328P usado no Arduino UNO não possui resistores suspensos integrados, apenas resistores pullup. Então, estamos usando isso. Os resistores pullup conectam cada pino de entrada a 5 V, garantindo que eles sempre leiam ALTO até que um botão seja pressionado.

Todas as linhas também são normalmente definidas como HIGH, o que evita que os pinos da coluna se conectem aos pinos da linha, independentemente de um botão ter sido pressionado ou não. Mas quando estivermos prontos para verificar uma linha, podemos definir essa linha como BAIXA . Se um botão nessa linha for pressionado, isso fornecerá um caminho para o pino de entrada ser puxado para o solo, resultando nessa coluna agora lendo como BAIXO .

Portanto, para resumir:definimos uma linha como BAIXA e, em seguida, verificamos quais pinos de coluna estão agora com A leitura BAIXA. Esses correspondem a botões pressionados. Este processo acontece muito rapidamente, para que possamos digitalizar todo o teclado muitas vezes por segundo. Meu código limita isso a 200 vezes por segundo, o que equilibra o desempenho, o salto e garante que cada tecla pressionada seja capturada.

Diodos, fantasmas e rollover de n-chave:

Os diodos no circuito existem para evitar pressionamentos involuntários de teclas quando certas combinações de botões são pressionadas. Os diodos permitem que a corrente flua apenas em uma direção, o que evita o efeito fantasma. Se não usarmos diodos, o pressionamento de certas teclas pode fazer com que outra tecla não pressionada seja registrada, pois a corrente flui através dos interruptores adjacentes. Isso é mostrado no gráfico simplificado onde pressionar qualquer coisa três teclas adjacentes faz com que a tecla no quarto canto seja registrada mesmo quando não é pressionada. Os diodos evitam isso e permitem "rollover de n-chave", o que significa que podemos pressionar quantas teclas quisermos em qualquer combinação que quisermos sem problemas.

Salvando pinos com um registro de deslocamento:

Os astutos entre vocês provavelmente notaram que eu disse que uma matriz de teclado requer um número de pinos igual à raiz quadrada do número de teclas, mas que eu também disse que o design do meu teclado requer apenas 11 pinos. Deve ser 16, certo? Não, porque estamos usando um registrador de deslocamento 74HC595. Este registrador de deslocamento nos permite usar apenas três dos pinos de E / S do Arduino para controlar até oito pinos de saída. Esses três pinos nos permitem enviar um byte (oito bits) para o registrador de deslocamento, que define seus oito pinos de saída como HIGH ou LOW. Usando o registrador de deslocamento para os pinos da linha de saída, salvamos 5 pinos de E / S inteiros!

"Então, por que não usar um registrador de deslocamento para os pinos de entrada também?" você pergunta. A resposta mais simples é que a entrada requer um tipo diferente de registrador de deslocamento e eu não tinha esse tipo disponível. Mas usar um registrador de deslocamento para entrada também complica a forma como lemos as colunas e pode causar problemas com ruído e "salto". Basta dizer que é uma dor de cabeça que não precisei enfrentar neste caso.
schematic.pdf

Etapa 2:Design de PCB

Projeto Esquemático

Agora que você entende como funciona uma matriz de teclado, meu design de PCB deve ser simples. Eu projetei o PCB no KiCAD (desculpe os juízes Eagle) e comecei com o esquema. Simplesmente coloquei um símbolo de botão e um símbolo de diodo, em seguida, copiei e colei-os até ter minha grade de 64 chaves. Em seguida, adicionei dois símbolos de cabeçalho de pino 1x8, um para as linhas e outro para as colunas. Um lado dos botões estava conectado em colunas e o outro lado dos botões estava conectado em linhas.

A próxima etapa foi atribuir pegadas de PCB a cada um desses símbolos esquemáticos. A biblioteca de footprint incluída do KiCAD tinha os footprints necessários integrados. Quando você está projetando seus próprios PCBs, você deve ter muito cuidado ao escolher as pegadas corretas, porque eles são o que realmente terminam em seu PCB. Existem muitos componentes que possuem pegadas muito semelhantes, mas com inclinações ligeiramente diferentes ou algo assim. Certifique-se de escolher aqueles que correspondem aos seus componentes do mundo real.

Pegadas e números de identificação

Preste atenção especial aos números dos pinos. O KiCAD tem um problema estranho onde os números dos pinos do símbolo do diodo esquemático não correspondem aos números dos pinos da pegada. Isso resulta em diodos invertidos, o que é um problema sério, dada sua polaridade. Não percebi esse erro e tive que jogar fora o primeiro lote de PCBs que encomendei. Para corrigir esse problema na segunda revisão, tive que criar uma pegada de diodo customizada com os números dos pinos trocados.

Layout PCB

Com o esquema feito e as pegadas atribuídas, mudei para o layout PCB real. O contorno da placa foi criado no Autodesk Fusion 360, exportado como DXF e, a seguir, importado para o KiCAD na camada Edge Cuts. A grande maioria do trabalho depois disso foi simplesmente organizar os botões para que tivessem um layout semelhante a um teclado normal.

Em seguida, todos os rastros foram encaminhados. Como o layout real do botão não corresponde à matriz organizada e organizada do esquema, essa parte ficou um pouco confusa e tive que recorrer ao uso de vias em alguns lugares. O Vias permite rotear um traço de uma camada para outra, o que é realmente útil quando você está usando uma placa de 2 camadas que tem muitos traços sobrepostos. Finalmente, adicionei regiões preenchidas, porque é uma boa prática.

Fabricação de PCB

Com o quadro projetado, simplesmente plotei todas as camadas e as adicionei a uma pasta zip. Essa pasta é fornecida aqui e pode ser carregada diretamente para um serviço de fabricação de PCB como o JLCPCB.

Aqui está o link para os arquivos Gerber PCB:https://drive.google.com/file/d/10YriLLtghV0Sb84Wm ...

Etapa 3:Montagem de PCB

Essa é a etapa mais fácil, porém entediante, de todo o projeto. Basta soldar todos os componentes no lugar. Eles são todos componentes de orifício e são fáceis de soldar. Preste atenção especial à orientação dos diodos. A marca nos diodos deve corresponder às marcas no PCB.

Na minha experiência, era mais fácil segurar o PCB no lugar com uma terceira mão e colocar todos os diodos primeiro. Em seguida, vire a placa e solde todos eles e, em seguida, prenda os cabos. Em seguida, coloque todos os botões e solde-os. Em seguida, solde os cabeçotes dos pinos no lugar. Você pode usar cabeçalhos de alfinetes femininos ou masculinos, a decisão é totalmente sua. Se você usar cabeça masculina e colocá-la por baixo a placa, o espaçamento é correto para colocá-los diretamente em uma placa de ensaio.

Etapa 4:conecte o teclado ao seu Arduino

A fiação parece complicada, mas realmente não é tão ruim quando você presta atenção para onde tudo está indo.

Oito fios de jumper irão do cabeçalho da coluna diretamente para os seguintes pinos do Arduino:

Coluna 1> A0
Coluna 2> A1
Coluna 3> A2
Coluna 4> A3
Coluna 5> A4
Coluna 6> A5
Coluna 7> 5
Coluna 8> 6

Em seguida, coloque o registrador de deslocamento 74HC595 em sua placa de ensaio abrangendo o intervalo intermediário. Observe a orientação do chip! O ponto indica o pino 1

Dê uma olhada no diagrama de fiação para ver onde vão as conexões de 5 V e terra. O registrador de deslocamento tem dois pinos conectados a 5 V e dois pinos conectados ao aterramento.

Apenas três fios são necessários para conectar o registrador de deslocamento ao Arduino. Eles são:

Shift (relógio) 11> 4
Shift (trava) 12> 3
Shift (dados) 14> 2

Por alguma razão boba, os pinos de saída do registrador de deslocamento são organizados de uma forma contra-intuitiva. Preste atenção especial ao diagrama de pinagem do registro de deslocamento ao conectá-lo aos pinos de sua linha. Eles são:

Linha 1> Shift (Q0) 15
Linha 2> Shift (Q1) 1
Linha 3> Shift (Q2) 2
Linha 4> Shift (Q3) 3
Linha 5> Shift (Q4) 4
Linha 6> Shift (Q5) 5
Shift 7> Shift (Q6) 6
Shift 8> Shift (Q7) 7

Nada está conectado aos pinos 0 ou 1 do Arduino, porque eles também são usados para a porta serial e causam conflitos.

Etapa 5:atualize o código do Arduino

Atualize seu Arduino com o código fornecido aqui. Não há nada de especial nisso, apenas carregue o código como faria com qualquer outro projeto Arduino.

Tudo no código tem comentários detalhados que você pode ler, então não entrarei em muitos detalhes aqui. Basicamente, os pinos são configurados como entradas e saídas. O loop principal contém apenas uma função de temporizador. A cada 5ms, ele chama a função de varredura do teclado. Essa função chama uma função separada para definir o registrador de deslocamento antes de cada coluna ser verificada. As teclas pressionadas imprimem seus valores em Serial.

Se você quiser alterar o que é impresso ao pressionar uma tecla, basta alterar o Serial.print ("_"); na instrução if que corresponde à condição. Por exemplo, você pode definir o que é impresso ao segurar FN e pressionar N. O mesmo se aplica a todas as outras teclas de cada modificador.

Muitas chaves não fazem nada neste código, porque ele está apenas imprimindo em Serial. Isso significa que a tecla backspace não tem efeito, porque você não pode excluir do monitor Serial - os dados já foram recebidos. Você é, no entanto, livre para usar as alterações que desejar.

Usando o teclado com seus próprios projetos

É bom imprimir em serial, mas esse não é realmente o objetivo deste teclado. O objetivo deste teclado é criar protótipos de projetos mais complexos. É por isso que é fácil alterar a funcionalidade. Se, por exemplo, você deseja imprimir o texto digitado em uma tela OLED, pode simplesmente substituir cada Serial.print ( com display.print ( ou o que quer que sua exibição particular exija. Replace All do IDE do Arduino ferramenta é ótima para substituir todos em uma etapa rápida.

Obrigado por ler isso e espero que este teclado ajude você com seus projetos!
ProtoKeyboardV1.1-Shifted.ino

Atualização de 30/01/21:

Este novo código foi completamente reescrito e tem um desempenho melhor do que o código original. Isso foi feito principalmente para resolver um problema com meu algoritmo que impedia que os caracteres fossem inseridos toda vez que uma tecla era pressionada. O código original foi verificado para garantir que uma determinada chave não fosse a última tecla a ser pressionada. Isso causava um problema se 2 ou mais teclas fossem pressionadas, o que faria com que algo como "fgfgfgfgfgfgfgfgfgfg" fosse inserido. Isso também evitava que você digitasse a mesma chave repetidamente com muita rapidez, como quando você digita os dois m na palavra "chatice".

O novo código resolve esses dois problemas e também é mais elegante. Em vez de acompanhar a última tecla a ser pressionada, verificamos o estado de todo o teclado e o comparamos com o estado inteiro do teclado no último loop. Isso significa que o loop pode ser executado muito mais rápido e você também pode inserir a mesma chave continuamente. O desempenho é melhorado drasticamente. Todos os personagens também estão em matrizes na parte superior, para que você possa localizá-los e alterá-los facilmente. Existem matrizes independentes para cada modificador. O código também é muito mais curto.

A única desvantagem dessa nova abordagem é que ela usa mais memória dinâmica - embora use significativamente menos espaço de programa. Em um Arduino Uno, ele agora usa:3532 bytes (10%) de espaço de armazenamento do programa e 605 bytes (29%) de memória dinâmica.

Como um bônus adicional, este código funciona tão bem em microcontroladores rápidos como o ARM Cortex-M4. O temporizador de intervalo para verificar o teclado está em microssegundos, portanto, terá o mesmo desempenho em qualquer placa. Você também pode ajustar facilmente a frequência com que o teclado é verificado. Por padrão, ele executa um loop a cada 500 microssegundos. São necessários 8 loops para verificar o teclado, para um total de 4.000 microssegundos (4 milissegundos ou 250 vezes por segundo) - embora possa demorar mais se o micro não for rápido o suficiente para executar o código tão rapidamente.

Código

ProtoKeyboardV1.1-Shifted.ino
ProtoKeyboardV1-Bits.ino

ProtoKeyboardV1.1-Shifted.ino Arduino

 Sem visualização (somente download).

ProtoKeyboardV1-Bits.ino Arduino

Código Arduino atualizado

 / * Sketch for Prototyping Keyboard V1.2 * por Cameron Coward 30/01/21 * * Testado no Arduino Uno. Requer PCB * personalizado e um registrador de deslocamento 74HC595. * * Mais informações:https://www.hackster.io/cameroncoward/64-key-prototyping-keyboard-matrix-for-arduino-4c9531 * / const int rowData =2; // shift register Data pin for rowsconst int rowLatch =3; // shift register Latch pin for rowsconst int rowClock =4; // desloca o pino do relógio do registro para as linhas // esses são os nossos pinos de entrada da coluna. O pino 0 e o pino 1 não são usados, // porque causam problemas (provavelmente porque são TX e RX) const int colA =A0; const int colB =A1; const int colC =A2; const int colD =A3; const int colE =A4; const int colF =A5; const int colG =5; const int colH =6; // shiftRow é o byte de registro de deslocamento necessário para cada linha, rowState conterá as teclas pressionadas para cada rowconst byte shiftRow [] ={B01111111, B10111111, B11011111, B11101111, B11110111, B11111011, B11111101, B11111110}; byte rowState [] ={B00000000, B00000000, B00000000, B0000St0000, B0000ate, B0000ate ] ={B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000}; // códigos ASCII para teclas sem modificadores pressionados. Os modificadores são NULL (0), // porque os verificaremos separadamente e seus valores não devem ser impressos.const char key [] ={0, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 45, 61, 0, 9, 113, 119, 101, 114, 116, 121, 117, 105, 111, 112, 91, 93, 92, 7, 97, 115, 100, 102, 103, 104, 106, 107, 108, 59, 39, 0, 0, 122, 120, 99, 118, 98, 110, 109, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0}; // códigos ASCII para teclas com shift pressionado E maiúsculas são caracteres ativos capsShiftKey [] ={0, 33, 64, 35, 36, 36, 37, 94, 38, 42, 40, 41, 95, 43, 0, 9, 113, 119, 101, 114, 116, 121, 117, 105, 111, 112, 123, 125, 124, 7, 97, 115, 100, 102, 103, 104, 106, 107, 108, 58, 22, 0, 0, 122, 120, 99, 118, 98, 110, 109, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0}; // Códigos ASCII para teclas com shift pressionado.const char shiftKey [] ={0, 33, 64, 35, 36, 37, 94, 38, 42, 40, 41, 95, 43, 0, 9, 81, 87, 69, 82, 84, 89, 85, 73, 79, 80, 123, 125, 124, 7, 65, 83, 68, 70, 71, 72, 74, 75, 76, 58, 22, 0, 0, 90, 88, 67, 86, 66, 78, 77, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0}; // Códigos ASCII para teclas com ctrl pressionado.const char ctrlKey [] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0}; // códigos ASCII para chaves com spcl pressionado.const char spclKey [] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Códigos ASCII para teclas com alt pressionado.const char altKey [] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // códigos ASCII para teclas com fn pressionado.const char fnKey [] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Códigos ASCII para chaves com maiúsculas is activeconst char capsKey [] ={0, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 45, 61, 0 , 9, 81, 87, 69, 82, 84, 89, 85, 73, 79, 80, 91, 93, 92, 7, 65, 83, 68, 70, 71, 72, 74, 75, 76, 59 , 39, 0, 0, 90, 88, 67, 86, 66, 78, 77, 44, 46, 47, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0 }; long previousKeyboardMicros =0; // armazenará a última vez que o teclado foi verificado // as variáveis a seguir são longas porque o tempo, medido em milissegundos, // se tornará rapidamente um número maior do que pode ser armazenado em um int.long keyboardInterval =500; // intervalo no qual verificar o teclado (microssegundos) int rowToCheck =0; // Verificamos uma linha por loop de checkKeyboard (), isso combinado com keyboardInterval // dá ao shiftRegister tempo para atualizar totalmente entre as verificações de linha caps =false; // o caps lock está ativado? bool shift =false; // shift para a esquerda ou para a direita pressionado? bool capsShift =false; // shift AND caps estão ativos? bool ctrl =false; // a tecla ctrl está pressionada? bool spcl =false; // a tecla spcl está pressionada? bool alt =false; // a tecla alt está pressionada? bool fn =false; // a tecla de função está pressionada? void setup () {Serial.begin (9600); // configura todos os pinos da coluna como entradas com resistores pullup internos pinMode (colA, INPUT_PULLUP); pinMode (colB, INPUT_PULLUP); pinMode (colC, INPUT_PULLUP); pinMode (colD, INPUT_PULLUP); pinMode (colE, INPUT_PULLUP); pinMode (colF, INPUT_PULLUP); pinMode (colG, INPUT_PULLUP); pinMode (colH, INPUT_PULLUP); // as saídas necessárias para controlar o registro de deslocamento 74HC595 pinMode (rowLatch, OUTPUT); pinMode (rowClock, OUTPUT); pinMode (rowData, OUTPUT); updateShiftRegister (B11111111); // certifique-se de que o registro de deslocamento comece em HIGH} void loop () {mainTimer ();} void mainTimer () {unsigned long currentMicros =micros (); // há quantos microssegundos o Arduino está executando? if (currentMicros - previousKeyboardMicros> keyboardInterval) {// se o tempo decorrido desde a última verificação excede o intervalo // salvar a última vez que o teclado foi verificado previousKeyboardMicros =currentMicros; checkKeyboard (); // verifica todas as chaves e imprime os resultados em serial}} void updateShiftRegister (byte row) {// esta função define o registro de deslocamento de acordo com o byte que foi passado para ela digitalWrite (rowLatch, LOW); // define latch para baixo para que possamos escrever um byte inteiro de uma vez shiftOut (rowData, rowClock, MSBFIRST, row); // escreve esse byte digitalWrite (rowLatch, HIGH); // definir a trava de volta para alto para que o registro de deslocamento permaneça estável até a próxima alteração} void checkKeyboard () {// definir o registro de deslocamento para o valor de byte da linha atual, a partir do array de bytes shiftRow [] updateShiftRegister (shiftRow [rowToCheck]); // Verifique cada coluna if (digitalRead (colA) ==LOW) {bitSet (rowState [rowToCheck], 0); } else {bitClear (rowState [rowToCheck], 0); } if (digitalRead (colB) ==LOW) {bitSet (rowState [rowToCheck], 1); } else {bitClear (rowState [rowToCheck], 1); } if (digitalRead (colC) ==LOW) {bitSet (rowState [rowToCheck], 2); } else {bitClear (rowState [rowToCheck], 2); } if (digitalRead (colD) ==LOW) {bitSet (rowState [rowToCheck], 3); } else {bitClear (rowState [rowToCheck], 3); } if (digitalRead (colE) ==LOW) {bitSet (rowState [rowToCheck], 4); } else {bitClear (rowState [rowToCheck], 4); } if (digitalRead (colF) ==LOW) {bitSet (rowState [rowToCheck], 5); } else {bitClear (rowState [rowToCheck], 5); } if (digitalRead (colG) ==LOW) {bitSet (rowState [rowToCheck], 6); } else {bitClear (rowState [rowToCheck], 6); } if (digitalRead (colH) ==LOW) {bitSet (rowState [rowToCheck], 7); } else {bitClear (rowState [rowToCheck], 7); } // definir todos os pinos do registrador de deslocamento para ALTO, evita que os valores "sangrem" para o próximo loop updateShiftRegister (B11111111); rowToCheck =rowToCheck + 1; // itera para a próxima linha // após verificar a 8ª linha, verifique os estados (pressionamentos de botão) e reinicie na 1ª linha if (rowToCheck> 7) {checkPressedKeys (); rowToCheck =0; }} void checkPressedKeys () {// verifique se alguma tecla shift foi pressionada if (bitRead (rowState [5], 1) | bitRead (rowState [6], 4)) {shift =true; } else {shift =false; } // verifique se alguma das teclas ctrl está pressionada if (bitRead (rowState [6], 5) | bitRead (rowState [7], 3)) {ctrl =true; } else {ctrl =false; } // verifique se alguma das teclas spcl foi pressionada if (bitRead (rowState [6], 6) | bitRead (rowState [7], 2)) {spcl =true; } else {spcl =false; } // verifique se a tecla alt está pressionada if (bitRead (rowState [6], 7) | bitRead (rowState [7], 1)) {alt =true; } else {alt =false; } // verifique se a tecla FN está pressionada if (bitRead (rowState [7], 4)) {fn =true; } else {fn =false; } // verificar caps está ativo e shift é pressionado if (shift ==true &&caps ==true) {capsShift =true; } else {capsShift =false; } for (int i =8; i> =0; i--) {// iterar em cada linha para (int j =7; j> =0; j--) {// iterar em cada bit dessa linha bool newBit =bitRead (rowState [i], j); // verifique o estado desse bit bool prevBit =bitRead (prevRowState [i], j); // verifique o estado anterior desse bit if ((newBit ==1) &&(prevBit ==0)) {// só permite pressionar o botão se o estado mudou para verdadeiro int thisChar =(i * 8) + j; // calcular qual posição na matriz de caracteres selecionar if (capsShift ==true) {processKey (capsShiftKey [thisChar]); } else if (shift ==true) {processKey (shiftKey [thisChar]); } else if (ctrl ==true) {processKey (ctrlKey [thisChar]); } else if (alt ==true) {processKey (altKey [thisChar]); } else if (spcl ==true) {processKey (spclKey [thisChar]); } else if (fn ==true) {processKey (fnKey [thisChar]); } else if (caps ==true) {processKey (capsKey [thisChar]); } else {processKey (key [thisChar]); }} if (newBit ==1) {bitSet (prevRowState [i], j); // define o estado do bit anterior como verdadeiro se uma tecla for pressionada} else {bitClear (prevRowState [i], j); // define o estado do bit anterior como falso se a tecla não for pressionada, para que possa ser pressionada novamente}}}} void processKey (char receivedKey) {if (receivedKey ==7) {// verificar funções especiais da mesma maneira como maiúsculas (adicionar novas instruções "else if") maiúsculas =! maiúsculas; } else {Serial.print (receivedKey); // se char não corresponde a uma função especial, basta imprimir esse char}}

Peças personalizadas e gabinetes

Faça upload de todo o arquivo .zip para o serviço de fabricação de PCB keyplots_4xipOSLHzg.zip

Esquemas

SMART CUBE:uma nova maneira de controlar sua casa Construa um Battle Bot controlado com um controlador PS2

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial