Programação MouseTeclado Arduino. MouseKeyboard Programação Arduino Bibliotecas de servo motores e motores de passo

10.09.2021

". Hoje conectamos o teclado matricial à placa Arduino e também consideramos esquemas interessantes com ela. Você mesmo pode fazer esse teclado com botões e uma placa de circuito impresso. O artigo contém instruções em vídeo, listas de programas, diagramas de conexão e componentes necessários.

A maior parte do texto contém uma explicação do código do programa, você pode baixá-lo ou assistir ao vídeo abaixo do artigo.

Você mesmo pode fazer esse teclado. Para isso você vai precisar PCB, 12 ou 16 botões normais e fios de conexão. Vou usar o já pronto.

Para que serve um teclado matricial?

Por exemplo, vamos pegar um botão normal. Como você sabe, este é o mais simples dispositivo eletromecânico. Para conectá-lo à placa, você precisa usar um resistor pull-down e também usar um contato de alimentação e um contato de aterramento cada. Ao pressionar esse botão, você pode realizar uma determinada ação, por exemplo, controlar um LED, várias unidades, mecanismos e assim por diante. E se precisarmos conectar vários botões? Então você terá que usar mais contatos e um número maior de fios, e não poderá ficar sem uma placa de ensaio, além de ter que usar mais resistores.

É por isso que criamos esse teclado para simplificar a conexão mais botões Esses dispositivos são encontrados em todos os lugares - em teclados de computador, calculadoras e assim por diante.

Deve ser conectado à placa com 8 pinos, cada um deles lê valores de determinadas linhas e colunas. Eles devem ser conectados aos pinos do painel Digital. Vou conectar, por exemplo, aos pinos 2 a 9 inclusive. Não é aconselhável tocar nos zero e nos primeiros, pois são destinados à interface UART (por exemplo, para conectar um módulo Bluetooth). É mais racional deixá-los livres.

Isso é o que mais parece circuito simples usando o teclado. Para tornar mais conveniente trabalhar com ele, a biblioteca Keypad foi escrita. Você pode baixá-lo, assim como outros esboços.

Depois de instalá-lo na biblioteca, você pode acessar o Arduino IDE (um programa do site do Arduino) e ver exemplos de esboços.

Vamos pegar o esboço mais simples como referência. Ele permite que você leia o valor do teclado quando você pressiona uma determinada tecla e os envia para a porta. Neste caso, é um monitor de porta em um computador.

#incluir // conecta nossa biblioteca

{"2","5","8","0"},
{"3","6","9","#"},
("A", "B", "C", "D")
};

configuração nula())(
Serial.begin(9600);
}
loop vazio()

if (customKey)(
Serial.println(customKey);
}
}

O esboço é muito simples. Vale a pena observar as primeiras linhas do código. Primeiro conectamos a biblioteca, depois indicamos quantas linhas e colunas o teclado possui e, a seguir, precisamos organizar corretamente os nomes das teclas para facilitar o trabalho.

Se isso for feito incorretamente, então, por exemplo, ao pressionar o número 4, o número 6 ou qualquer outro símbolo será enviado para a porta. Isso pode ser determinado empiricamente e os caracteres podem ser organizados conforme estão localizados no teclado.

Em função configuração nula indique a velocidade conexão serial com monitor de porta 9600 bauds. A função só é necessária para fornecer energia aos módulos. Em função Ciclo Vazio nós anotamos a condição. Variável Caráteré usado para armazenar apenas um caractere, como 1, A ou 5, o que for mais adequado à situação. Se a prensa estiver registrada, o símbolo será enviado para o monitor de porta usando a função Impressão em série. Entre parênteses você precisa indicar qual variável está sendo enviada para a porta. Se tudo for feito corretamente, no monitor da porta receberemos o símbolo que foi clicado. Não se esqueça de definir a taxa de transferência de dados no monitor da porta no canto inferior direito para a mesma do esboço.

Circuito com display e teclado matricial

Vamos exibir os dados.

Eu uso um display com interface com um módulo I2C que facilita a fiação. Para trabalhar com um display com barramento I2C, é necessário instalar outra biblioteca. Você pode baixá-lo.

Em seguida, você precisa especificar o tamanho da exibição. O display utilizado no exemplo contém 16 caracteres em cada uma das 2 linhas, que é o que indico. Em função Configuração de vazio Você precisa fornecer energia ao display e ligar a luz de fundo. Isso é feito usando duas funções: lcd.begin E lcd.luz de fundo.

#incluir // conecta nossa biblioteca
#incluir
LiquidCrystal_I2Clcd(0x27, 16, 2);
const byte LINHAS = 4; //número de linhas do nosso teclado
byte constante COLS = 4; //número de colunas do nosso teclado
char hexaKeys = (
(“S”,”4”,”7”,”*”), // aqui colocamos os nomes das nossas teclas, como em um teclado, para facilitar o uso
("O","5","8","0"),
("S","6","9","#"),
("I", "B", "C", "D")
};
byte rowPins = (5, 4, 3, 2); //a quais pinos conectamos o controle de linha
byte colPins = (9, 8, 7, 6); //a quais pinos conectamos o controle de coluna
//inicializa uma instância da classe NewKeypad
Teclado customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
configuração nula())(
Serial.begin(9600);
lcd.begin(); // Inicializa a tela
lcd.luz de fundo();
}
loop vazio()
char customKey = customKeypad.getKey();
if (customKey)(
Serial.println(customKey);
lcd.setCursor(1,4); //define o cursor
lcd.print(customKey);
}
}

Em função Voil Loop você precisa escrever uma linha na própria condição lcd.imprimir para exibir dados. E você também precisa primeiro definir a posição do cursor. Existem 2 dígitos entre colchetes: o primeiro é o número do caractere e o segundo é o número da linha. Deve ser lembrado que esta exibição começa a contar linhas e colunas não de um, mas de zero. Ou seja, existem linhas numeradas 0 e 1, e não 1 e 2, como pode parecer à primeira vista. Então carregaremos o código no quadro e veremos o que acontece.

Como o display opera através da interface I2C, nós o conectamos aos pinos analógicos. Conectamos as saídas SDA e SCL em A4 e A5, respectivamente, e as duas restantes já são alimentação e terra.

Como você pode ver, ao clicar em qualquer símbolo, vemos sua exibição no display.

Para apagar uma linha, lembre-se da calculadora. Quando precisávamos excluir um valor, pressionamos o botão reset. Clique neste botão no quadro e podemos redigitar os caracteres.

Conectando o teclado ao Arduino e controlando a ação

O último diagrama da lição consiste em executar uma determinada ação quando uma tecla específica é pressionada. Este é o principal objetivo da conexão teclado matricial para Arduino. Haverá dois artigos e vídeos separados sobre este tópico, descrevendo circuitos mais complexos e interessantes. Agora vamos nos familiarizar com este módulo e lembrar como construir código usando-o.

Vamos tentar ligar ou desligar o LED ao pressionar uma determinada tecla. Adicione-o ao diagrama.

Conexão LED

Usarei uma placa de ensaio e um resistor (de preferência entre 150 e 220 ohms). Fecharei o circuito com dois jumpers, conectando-os aos pinos de alimentação e aterramento da placa Arduino.

O circuito funcionará assim: ao pressionar 1 o LED acende, ao pressionar 2 ele apaga.

O LED do exemplo está conectado ao pino 8 da placa Arduino.

#incluir
const byte LINHAS = 4; //Quatro linhas
byte constante COLS = 4; //Três colunas
char keys = ( // Define o mapa de teclado
("1","4","7","*"), // aqui colocamos os nomes das nossas teclas, como em um teclado, para facilitar o uso
{"2","5","8","0"},
{"3","6","9","#"},
("A", "B", "C", "D")
};
byte rowPins = ( 5, 4, 3, 2 ); // Conecte o teclado ROW0, ROW1, ROW2 e ROW3 a esses pinos do Arduino.
byte colPins = (9, 8, 7,6); // Conecte o teclado COL0, COL1 e COL2 a esses pinos do Arduino.
Teclado kpd = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
#define ledpin 8
configuração nula()
{
pinMode(ledpin,SAÍDA);
Serial.begin(9600);
}
loop vazio()
{
chave char = kpd.getKey();
if(key) // Verifica se há uma chave válida.
{
interruptor (chave)
{
caso "1":
digitalWrite(ledpin, ALTO);
quebrar;
caso "2":
digitalWrite (pino led, LOW);
quebrar;
}
}
}

Vejamos o esboço.

Vamos pegar o primeiro esboço da lição e simplesmente adicionar algo a ele. No início com uma função útil Definir atribua um nome ao LED conectado ao pino 8 pino de led. Em função Anular configuração especifique o sinal do LED como saída.

Se não fosse pela biblioteca Teclado para o teclado, você teria que escrever o mesmo para os 8 pinos aos quais o teclado está conectado. Em função ciclo vazio doença. Pressionar uma determinada tecla é “igualado” ao valor da variável chave. A instrução Switch compara os valores de uma variável chave e “dá” certos comandos dependendo deste valor. Consiste em dois operadores auxiliares Caso E Quebrar. Simplificando, se for encontrado um valor de variável igual a 1, a ação será executada. Operador quebrar serve como um comando de saída da instrução Caso.

Assim, ao pressionar 1, a tensão máxima será aplicada ao LED e ele acenderá. Quando você pressiona 2, ele não acende. Isso é especificado na função Escrita digital, onde entre parênteses são dados o nome da variável e a “indicação” da mesma. Você pode assim escrever comandos específicos para cada botão e controlar um grande número de LEDs, ou criar um comando para acender todos os LEDs de uma vez.

Essas bibliotecas principais permitem Placas Arduino Leonardo, Micro ou Due quando conectados a um computador são detectados como um mouse e/ou teclado normal.

Precauções ao usar as bibliotecas Mouse e Teclado: Se as bibliotecas Mouse ou Keyborad estiverem constantemente em execução, poderão surgir dificuldades na programação do seu dispositivo. Funções como Mouse.move() ou Keyboard.print() podem mover o cursor e sinalizar o pressionamento de teclas para o computador conectado, portanto, só devem ser chamadas quando você estiver pronto para controlar sua operação. Recomenda-se a utilização de algum tipo de sistema de controle que permita desligar tal funcionalidade, por exemplo, dependendo da posição de uma chave ou de um sinal em um pino cujo estado você pode controlar.

Antes de usar as funções da biblioteca Mouse ou Teclado diretamente com seu computador, é melhor testar seus valores de retorno usando a função Serial.print(). Desta forma você poderá verificar se os valores que estão sendo enviados estão corretos. Para obter mais detalhes, veja exemplos de trabalho com as bibliotecas de mouse e teclado abaixo.

Mouse (biblioteca de mouse)

As funções do mouse permitem que Leonardo, Micro ou Due controlem o movimento do cursor em um computador conectado. A posição do cursor é sempre atualizada em relação à sua posição anterior.

Teclado (biblioteca de teclado)

As funções do teclado permitem que Leonardo, Micro ou Due enviem sinais de pressionamento de tecla para o computador conectado.

Observação: A biblioteca Teclado não permite o envio de todos os caracteres ASCII e, em particular, não permite o envio de caracteres não imprimíveis. A biblioteca também suporta o uso de teclas modificadoras, que, quando pressionadas simultaneamente com outra tecla, alteram seu comportamento. Informações adicionais

sobre chaves suportadas e seu uso.

Exemplos
KeybaordAndMouseControl: Demonstração de comandos de mouse e teclado em um programa.

KeyboardMessage: envia uma string de texto quando um botão é pressionado.

Essas bibliotecas principais permitem que placas baseadas em 32u4 ou placas Due e Zero apareçam como um mouse e/ou teclado nativo em um computador conectado. Uma palavra de cautela ao usar as bibliotecas de mouse e teclado

: se a biblioteca do Mouse ou Teclado estiver constantemente em execução, será difícil programar sua placa. Funções como Mouse.move() e Keyboard.print() moverão o cursor ou enviarão pressionamentos de tecla para um computador conectado e só deverão ser chamadas quando você estiver pronto para manipulá-las. Recomenda-se usar um sistema de controle para ativar essa funcionalidade, como um interruptor físico ou respondendo apenas a entradas específicas que você pode controlar.

Ao usar a biblioteca Mouse ou Teclado, talvez seja melhor testar sua saída primeiro usando Serial.print(). Dessa forma, você pode ter certeza de saber quais valores estão sendo informados. Consulte os exemplos de mouse e teclado para ver algumas maneiras de lidar com isso.

Rato

As funções do mouse permitem que Leonardo, Micro ou Due controlem o movimento do cursor em um computador conectado. Ao atualizar a posição do cursor, ela é sempre relativa à localização anterior do cursor.

Teclado

As funções do teclado permitem que Leonardo, Micro ou Due enviem pressionamentos de tecla para um computador conectado. Nota: Nem todos os caracteres ASCII possíveis, especialmente os não imprimíveis, podem ser enviados com a biblioteca Teclado

. A biblioteca suporta o uso de teclas modificadoras. As teclas modificadoras alteram o comportamento de outra tecla quando pressionadas simultaneamente. para obter informações adicionais sobre chaves suportadas e seu uso.

Exemplos
: demonstra os comandos do mouse e do teclado em um programa.
: Efetua logout do usuário atual com comandos de teclas
: Lê um byte da porta serial e envia de volta um pressionamento de tecla.

Até agora só trabalhamos com Arduino UNO. Sim, mas o que vou mostrar hoje não funciona com Arduino UNO. Na verdade, é possível, claro, mas neste caso você precisa enganar alguma coisa, e isso não é tão fácil. O que fazer então? Aqui está o que.

Além do Arduino UNO, existem muitas outras versões do Arduino. Isso inclui Arduino Nano ou Mini, quando o tamanho importa, e Arduino Mega, quando não há mais pinos e recursos suficientes no UNO e você ainda precisa conectar um quilograma de sensores. E se você realmente gosta do formato UNO, mas não há pinos analógicos suficientes, Leonardo virá em seu socorro.

Hoje vamos nos concentrar em Leonardo. A diferença entre Leonardo e UNO não está apenas nos pinos analógicos adicionais, mas também na arquitetura. Uma porta serial virtual está disponível no Leonardo. O que isso nos dá? No mínimo, os pinos 1 e 0, responsáveis pela conexão ao computador no UNO, permanecem livres e, quando a conexão serial é aberta, a placa não reinicia. Leve isso em consideração. E o principal trunfo é que o computador considera Leonardo um dispositivo HID (Dispositivo de interface humana), o que significa que Leonardo pode fingir ser um teclado ou mouse. Esta é a propriedade que usaremos.

Fundo

Adoro tocar guitarra elétrica. Costumo tocar no programa Guitar Rig. Este programa é um processador virtual de guitarra, ou seja, processa o som da guitarra. Para que serve tudo isso? Ao jogar, você precisa alternar entre as predefinições, mas suas mãos estão ocupadas. Existe uma solução - comprar um controlador para este programa, mas ele não é mais produzido e custa muito caro. E se você mesmo construir um pedal? Isto é o que resultou disso.

Nós precisaremos

Arduino Leonardo ou seus análogos

O principal é que a placa seja definida como um dispositivo HID

Botão

Depende do seu gosto

Conectando fios

Quadro

Há espaço para ideias de design correrem soltas aqui. Decidi não me preocupar muito e construí algo parecido com um pedal com dois pedaços de compensado generosamente untados com cola quente. Entregar-se é o certo.

Meio reino para cola quente.

Um dos HIDs

Como já disse, Leonardo pode fingir ser um teclado ou mouse. Isso é feito usando a biblioteca integrada. Abaixo está um exemplo de código. Tente executá-lo em seu computador. Uma coisa estranha está para acontecer.

// Conecta a biblioteca para controlar o teclado #include "Keyboard.h" void setup() ( // Inicia Keyboard.begin(); delay(3000); // Seleciona todo o documento Keyboard.press(KEY_LEFT_CTRL); Keyboard. press(" a"); delay(500); Keyboard.releaseAll(); // Apagar o texto Keyboard.write(KEY_BACKSPACE); controlando seu teclado") ; delay(1000); // Selecione o documento inteiro Keyboard.press(KEY_LEFT_CTRL); Keyboard.press("a"); Keyboard.releaseAll(); // Escreva a mensagem Keyboard.println("Adeus !" ); delay(1000); // Seleciona o documento inteiro Keyboard.press(KEY_LEFT_CTRL); delay(500); // Apaga o texto Keyboard.write(KEY_BACKSPACE); delay(500); Keyboard.releaseAll(); // Salva o documento Keyboard.press(KEY_LEFT_CTRL); // Para reverter tudo.

Não tenha pressa em correr e falar sobre a revolta das máquinas. Foi assim que foi planejado. Agora vamos descobrir como isso funciona.

Teclado.imprensa(botão) – este comando diz ao Leonardo para pressionar um botão no teclado. O argumento leva uma letra ou designador de chave especial. KEY_LEFT_CTRL é o Ctrl esquerdo, por exemplo. Todas as designações podem ser visualizadas.

Você pode pressionar combinações de teclas. Para fazer isso, escreva algumas linhas de código com as chaves necessárias. Por exemplo, para salvar texto existe uma combinação de Ctrl + s, Leonardo também poderá salvar texto se você executar o seguinte código:

Teclado.press(“s”); Teclado.press(KEY_LEFT_CTRL);

Teclado.releaseAll() – o comando manda Leonardo soltar as chaves. Observe que o comando anterior apenas diz ao Leonardo para pressionar uma tecla. Se você não especificar Keyboard.releaseAll(), a tecla continuará a ser pressionada. Assim como na realidade. Tente abrir editor de texto e mantenha pressionada a tecla.

Teclado.println("Algunstexto") – este comando é responsável por imprimir o texto. Tudo está muito claro aqui. Funciona como Serial.println.

Existem outras funções, mas estas são as mais básicas. Temos o suficiente deles para fazer um pedal de guitarra. Se alguém estiver interessado no que mais há nesta biblioteca ou em uma semelhante para mouse, você pode abrir exemplos/USB e ler. Vamos prosseguir com a montagem do pedal.

Esquema

Você pode pensar no design e o diagrama de circuito do dispositivo é extremamente simples. Abaixo está um diagrama em uma placa de ensaio.

Código

// Conecta a biblioteca para trabalhar com o Leonardo como teclado #include "Keyboard.h" // Define o pin do botão #define BUTTON_PIN A0 // Cria uma variável para leitura das leituras do botão bool button = 0; void setup() ( // Abre uma conexão com a porta COM Serial.begin(9600); // Define o botão como uma entrada com um resistor pull-up // O que é um resistor pull-up e por que ele é necessário pode ser lido aqui: // http://site /arduino/arduino185.php pinMode(BUTTON_PIN, INPUT_PULLUP); void loop() ( // Ler leituras do botão button = digitalRead(BUTTON_PIN); // Lembre-se disso no estado liberado o valor no botão é 1 if(!button) ( // Envia a chave para Serial. Decidi enviar n // Para algumas teclas existem símbolos especiais. // Por exemplo, para enviar Shift esquerdo, você faria escreva um comando como este - Keyboard.press(KEY_LEFT_SHIFT); // Os códigos para outras teclas são fornecidos aqui // https://www.arduino.cc/en/Reference/KeyboardModifiers Keyboard.press("n"); Espere um pouco delay(10) else ( // Quando o botão for liberado, envie um comando para parar de pressionar Keyboard.releaseAll();

Vídeo

O vídeo mostra um teste do dispositivo em Microsoft Word e usá-lo como pedal para alternar presets na guitarra Rig 5. Para isso, criei um novo controlador, memorizei a tonalidade e configurei a ação.

Resultado final

Acontece que existem outros Arduinos que não são menos úteis e, em alguns casos, até mais úteis que o UNO.

Usando Leonardo como teclado ou mouse você pode criar coisas interessantes. Por exemplo, uma unidade flash de 1º de abril, que pressionará teclas em determinados intervalos. Essa coisinha vai dar ao seu alvo muitas emoções inesquecíveis. Apenas shh, eu não disse isso.

Muitas vezes, as mesmas partes do código migram de um programa para outro. Por exemplo, código para trabalhar com um sensor. Para não escrever este código novamente todas as vezes, ele é colocado em arquivos separados- bibliotecas. Uma grande quantidade de código pronto já foi escrito por outras pessoas e, com a ajuda de bibliotecas, você pode usá-lo facilmente em seus programas.

Conectando bibliotecas

Bibliotecas incluídas no Arduino IDE

Existem muitas bibliotecas incluídas IDE do Arduino. Você pode adicionar uma biblioteca ao seu código no menu Esboço Importando bibliotecas... Nome da biblioteca :

Após selecionar o item “Servo”, o Arduino IDE irá inserir as linhas necessárias no código:

#incluir configuração vazia() ( //código de instalação, executado uma vez) loop vazio() ( // código principal, executado ciclicamente após o código de instalação }

Claro, se você souber o nome da biblioteca que precisa, você pode simplesmente escrever #include no topo do esboço - o resultado será o mesmo.

Para ver um exemplo de trabalho com a biblioteca incluída no Arduino IDE, você precisa selecionar no menu Amostras de arquivos Nome da biblioteca Nome de exemplo

Bibliotecas de terceiros

Existem muitas bibliotecas para Arduino. E apenas uma pequena parte deles está incluída no IDE do Arduino. Muitas bibliotecas podem ser encontradas no GitHub.

Vamos tentar adicionar uma biblioteca para trabalhar com um indicador de quatro dígitos ao nosso projeto. Um link para a biblioteca para trabalhar com ela está na página de descrição do produto. Se você acessar a página da biblioteca, poderá ver muitos arquivos da biblioteca e exemplos de como trabalhar com eles. Mas por enquanto estaremos interessados apenas no botão Baixar ZIP :
Após clicar nele, será iniciado o download do arquivo zip com todos os arquivos da biblioteca. Neste caso será o arquivo QuadDisplay-master.zip. O nome da biblioteca só pode consistir em letras e números latinos, e o nome não pode começar com um número, então vamos renomear nosso arquivo imediatamente. Agora será chamado QuadDisplay.zip.

Após baixar o arquivo, você precisa ir ao IDE do Arduino e importar a biblioteca para sua pasta de trabalho Sketchbook/libraries, que deve conter todas as bibliotecas de terceiros. Você pode fazer isso diretamente do Arduino IDE, no menu Esboço Importando bibliotecas... Adicionar biblioteca...:
Uma caixa de diálogo será aberta na qual você precisa selecionar nosso arquivo QuadDisplay.zip e clicar no botão Abrir. Preparar. Agora bibliotecas podem ser adicionadas ao código. Exemplos de trabalho com a biblioteca estão disponíveis no menu Arquivo de bibliotecas do Sketchbook Nome da biblioteca Nome de exemplo

No Arduino 1.6.7 e superior: Exemplos de arquivos Nome da biblioteca Nome de exemplo

Criando uma biblioteca

Normalmente, ao criar uma biblioteca, são criados dois arquivos: um arquivo de cabeçalho e um arquivo com o código da biblioteca. Vamos tentar escrever uma biblioteca que nos permita calcular a área de um círculo. Vamos criar uma pasta no diretório %Sketchbook%\Arduino\libraries com o nome da nossa biblioteca (o nome só pode consistir em letras e números latinos e não pode começar com um número). Vamos chamar nossa biblioteca de CircleArea. Vamos até a pasta que criamos %Sketchbook%\Arduino\libraries\circleArea e criamos dois arquivos lá:

CircleArea.h - arquivo de cabeçalho

CircleArea.cpp - arquivo com código da biblioteca.

O código para CircleArea.h será assim:

círculoArea.h #incluir #define PI 3.14 // duas casas decimais - precisão suficiente. //Declara nossa função de biblioteca, para a qual tudo foi iniciado float círculoArea(raio flutuante);

O código CircleArea.cpp será assim:

círculoArea.cpp #incluir // útil, usaremos tipos numéricos #incluir // pegaremos a função pow() daqui #incluir // o arquivo de cabeçalho contém PI e declaração de função //Implementamos nossa função de biblioteca, para a qual tudo foi iniciado float círculoArea(float raio) ( return PI* pow (raio, 2 ) ; )

Usar a biblioteca no sketch seria assim:

círculoArea.ino #include configuração vazia() ( // coloque seu código de configuração aqui, para executar uma vez: Serial.begin(9600); ) loop vazio() (//coloque seu código principal aqui, para executar repetidamente:< 5 ; ++ i ) { Serial.print ("circle area with radius " ) ; Serial.print (i) ; Serial.print (" = " ) ; Serial.println (circleArea(i) ) ; } }

Compartilhe este artigo: