Receptor USB ATtiny85 IR: 11 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

AVISO, ESTE INSTRUÍVEL TORNOU-SE OBSOLETO

A biblioteca v-usb foi projetada para funcionar com protocolo USB 1.1 que quase não existe hoje em dia. Com a chegada do USB3, você terá mais do que uma dor de cabeça tentando fazer os dispositivos v-usb funcionarem. Depois de trocar meu centro de multimídia, tive muitos problemas de estabilidade e, embora o receptor funcione, depois de um tempo ele para de funcionar. Não tive sucesso ao tentar consertá-lo. Também fiz uma versão atmega328p, mas esta tinha os mesmos problemas. Usar um cronômetro de watchdog para reiniciar a placa periodicamente também não ajudou, então desisti do v-usb.

Faça um favor a si mesmo e não prossiga com este instrutível, a menos que seja para fins educacionais. Em vez disso, recomendo comprar um módulo de chip ATmega 32U4 que já integrou a interface USB e seguir este guia:

www.sparkfun.com/tutorials/337

Em seguida, coloque um sensor de infravermelho TSOP31238 e você está pronto para ir.

Olá fabricantes! este é um instrutível para construir um receptor IR USB funcional usando um microcontrolador Attiny85. Comecei este projeto para superar a falta de suporte (pelo menos suporte completo) para alguns remotos IR no sistema operacional GNU / Linux. Seguindo essas instruções, você pode construir um receptor IR USB programável que funcione com qualquer controle remoto IR por alguns dólares.

Em primeiro lugar, este instrutível não existiria sem o árduo trabalho das pessoas que criaram as bibliotecas que utilizo aqui:

• David A. Mellis por seu núcleo attiny
• Rowdy Dog Software para sua biblioteca TinyTuner
• Rowdy Dog Software para seu minúsculo bootloader
• Rancidbacon (https://rancidbacon.com/) por sua porta arduino da biblioteca v-usb (https://code.google.com/archive/p/vusb-for-arduino/downloads)
• seejaydee para sua biblioteca IR para pequenos núcleos encontrados nos comentários do código https://www.instructables.com/id/Attiny-IR-librar… instrutível em https://www.instructables.com/id/Attiny-IR -librar…

Às vezes não é fácil encontrar o proprietário certo de uma biblioteca, então caso eu cometa um erro, deixe um comentário e eu resolveria o problema o mais rápido possível.

Este guia existe porque não encontrei um tutorial / guia completo funcionando fora da caixa (pode existir, mas não consegui encontrar), então reuni todas as informações disponíveis na web e após uma boa quantidade de testes e erros Eu vim com um guia completo para construir um receptor USB IR funcional que realmente funciona muito bem.

As principais fontes de informação que tenho seguido:

• https://nathan.chantrell.net/20121014/tinypcremot…
• https://forum.arduino.cc/index.php?PHPSESSID=ap4jg…
• https://blog.petrockblock.com/2012/05/19/usb-keybo…
• https://learn.adafruit.com/using-an-infrared-libr…
• https://codeandlife.com/2012/03/03/diy-usb-passwor…
• https://codeandlife.com/2012/02/22/v-usb-with-atti…
• https://www.instructables.com/id/Attiny-IR-librar…

Etapa 1: algumas considerações

• Não tenho um programador AVR ISP e não estou muito interessado em comprar um, então usei um Arduino para programar o attiny85
• Eu não me importo com nenhum outro sistema operacional além do GNU / Linux, então não sei se isso vai funcionar de outra forma.
• existem outras bibliotecas IR, mas não consegui fazê-las funcionar nem mesmo com um arduino. Porém, considere que comecei com um conhecimento limitado sobre bibliotecas de RI. Talvez eu pudesse fazê-los funcionar agora, depois da experiência adquirida em lidar com uma boa quantidade de questões. De qualquer forma, estava perdido e desesperado antes de encontrar a biblioteca que Seejaydee forneceu e tenho usado desde então (muito obrigado cara!).
• Existem outras configurações de hardware, mas eu só usei aquela que usa 5V para alimentar o attiny85 e dois diodos zener 3,6V 0,5W para controlar a tensão das linhas de dados, funciona fora da caixa, então não mexi com outras configurações.
• Você pode usar um cristal de 16 MHz ou pode usar a biblioteca do tinytuner para calibrar o relógio interno do seu attiny85. Aconselho fortemente o uso do cristal, é muito mais estável e provavelmente vai lhe poupar muitas dores de cabeça.
• Estou usando aqui dois bootloaders diferentes para o attiny85:

a) Versão Rowdy Dog Software, possui uma interface serial integrada muito bacana e muito pequena para que você tenha mais espaço para seu programa e outras bibliotecas. O problema é que por alguns motivos, embora funcione muito bem, depois de algum tempo o dispositivo usb foi desconectado (você pode encontrar os problemas com o comando dmesg). Não sei se isso é um problema do núcleo ou uma combinação mista do núcleo mais as bibliotecas escolhidas, então depois de um tempo decidi usar este núcleo apenas para decodificar as chaves remotas e calibrar o relógio (quando não estiver usando um 16Mhz cristal). Depois disso, eu apenas queimo o bootloader Mellis e carrego o esboço definitivo que não usa a interface serial.

b) Versão Mellis, bootloader estável, tenho usado em muitos projetos. Eu teria usado este bootloader sempre se ele tivesse incluído uma interface serial. Eu uso este núcleo no esboço final depois de decodificar todas as chaves em meus controles remotos.

Etapa 2: vamos começar com o hardware

Ferramentas de que você precisa:

• uma placa compatível com arduino
• um adaptador serial para USB para decodificar suas chaves remotas (basta usar um FT232RL)
• um PC com GNU / Linux instalado e o IDE arduino configurado corretamente, estou usando o IDE arduino 1.8.0
• um remoto IR para testar seu dispositivo (mesmo um de baixa qualidade, como os encontrados nos kits iniciais do arduino, funcionará)
• um multímetro para depurar sua placa (espero que você não precise, boa sorte!)

A lista de materiais:

• 1 attiny85
• 2 resistores 68R
• 1 resistor de 1.5K
• 1 resistor de 4,7K
• 1 cristal de 16 MHz
• 1 capacitor 22pF
• 1 capacitor 0.1uF
• 1 capacitor 10uF
• 2 diodos zener 3,6 V 0,5 W
• 1 conector USB tipo A macho
• 1 pino de tira com 6 pinos para programar e depurar a placa.
• 1 sensor IR TSOP31238
• muito café para te manter acordado

Antes de soldar a placa definitiva, você provavelmente gostaria de fazer um protótipo de placa de ensaio para fins de teste, seguir o esquema anexado a este instrutível deve ser o suficiente para construí-lo.

Para conectar o attiny85 ao PC, o design final usa um conector USB tipo A que é soldado na placa, mas para o protótipo você precisará fazer um cabo USB que pode ser conectado a uma placa de ensaio:

Solde em um pequeno pedaço de 4 pinos do perfboard, depois corte um cabo USB antigo e solde os pinos em 4 dos fios dentro do cabo USB:

• vermelho é VCC (5V)
• preto é GND
• branco é D-
• verde é D +

Mantenha tudo junto com cola quente.

Agora precisamos conectar o programador ISP (Arduino), o adaptador USB para serial (FT232RL) e o sensor IR ao attiny85.

Você pode deixar todos conectados para poder gravar diferentes bootloaders, carregar esboços e verificar a porta serial sem mudar os fios, Para fazer isso, conecte tudo seguindo estas instruções:

Programador ISP (Arduino): isso nos permite queimar bootloaders e carregar esboços

• attiny85 PB0 (pin5) a pin11 (MOSI) em Arduino
• attiny85 PB1 (pin6) a pin12 (MISO) em Arduino
• attiny85 PB2 (pin7) para pin13 (SCK) em Arduino
• attiny85 RESET (pin1) com pullup (4,6k para VCC) para pin10 em Arduino
• attiny85 VCC a 5V em arduino
• attiny85 GND para GND em Arduino

USB para adaptador serial (FT232RL): isso nos permite verificar a porta serial

• attiny85 PB0 (pin5 RX) para TX no FT232RL
• attiny85 PB2 (pin7 TX) para RX no FT232RL
• attiny85 GND (pin4) para GND no FT232RL
• como o attiny85 já é alimentado pelo arduino você não precisa conectar o 5v no FT232RL, caso contrário conecte: attiny85 VCC (pin8) a 5V no FT232RL

USB para adaptador serial (FT232RL) apenas para a calibração do relógio (apenas para o bootloader "ATtiny85 @ 8MHz (oscilador interno; BOD desativado)")

• PB4 (pino 3 RX) para TX no FT232RL attiny85
• PB3 (pin2 TX) para RX no FT232RL attiny85
• GND (pin4) para GND no FT232RL
• como o attiny85 já é alimentado pelo arduino você não precisa conectar o 5v no FT232RL, caso contrário conecte: attiny85 VCC (pin8) a 5V no FT232RL

Se você usar um cristal de 16 MHz, conecte-o aos pinos PB3 (pino 2) e PB4 (pino 3) do Attiny85 e conecte cada pino ao GND através de uma tampa de 22pF cada.

Filtro Attiny85 VCC com capacitores de 0,1uF e 10uF conectando-os em paralelo ao GND

Conecte o pino de saída do sensor IR ao attiny85 PB1 (pino 6), ligue-o.

Crie e conecte a interface USB:

• GND (fio preto): conecte-o ao GND comum (todos os aterramentos estão conectados juntos)
• D- (fio branco) conectado a attiny85 PB0 (pino 5) por meio de um resistor 68R, conecte-o também ao aterramento por meio de um zener de 3,6 V 0,5 W e puxe-o até VCC com um resistor de 1,5 K
• D + (fio verde) conectado ao PB2 por meio de um resistor 68R, conecte-o ao aterramento por meio de um zener de 3,6 V 0,5 W
• 5V, você pode deixá-lo desconectado já que tudo é ligado pelo Arduino neste estágio, caso contrário, conecte-o ao attiny85 VCC

Os diodos zener são conectados de forma que os ânodos sejam ligados ao GND e os cátodos sejam conectados às linhas de dados D + e D-.

Etapa 3: Design final

Para o projeto final, você pode usar perfboard com componentes de orifício ou gravar sua própria placa e usar componentes smd. Para aprender como gravar uma placa, basta pesquisar no Google, há tutoriais incríveis disponíveis online.

Eu gravei minha própria placa e estou muito feliz com os resultados finais (placa pequena, estável e robusta). Sim, eu sei que o corte é uma merda, mas não consegui usar nenhuma ferramenta elétrica tão tarde da noite e eu apenas corte a tábua com minha tesoura de estanho.

A propósito, os traços nas imagens não são cobre puro, eles foram tratados com um produto químico desagradável que estanha levemente o cobre (suspeita-se de induzir câncer, então use-o com muito cuidado, globos de látex e uma máscara contra poeira):

Use o esquema acima para projetar seu layout ou você pode apenas usar minha pegada de pcb para gravar sua placa.

Etapa 4: lidando com o software

O circuito neste projeto é muito fácil, mas o software requer um esforço maior.

Precisamos de pelo menos 2 bibliotecas (mais uma se você não estiver usando um cristal) mais 2 bootloaders para fazer isso funcionar. Quando comecei este projeto, testei algumas bibliotecas, às vezes elas não funcionavam e muitas vezes simplesmente não estavam configuradas para funcionar com um Attiny85 pronto para uso (eu não sabia disso ainda). Então eu encontrei problemas com interrupções de sobreposição de bibliotecas / bootloaders. Finalmente, tive que lidar com uma boa quantidade de erros ao conectar o circuito final ao meu PC. Eu não tinha este guia, então acho que você ficaria bem, apenas siga os passos neste instrutível, se você fizer isso sem cometer erros, você deve estar bem:)

Precisamos agora instalar e configurar algumas bibliotecas:

• Biblioteca v-usb para arduino: esta biblioteca permite que o microcontrolador seja reconhecido pelo PC como um teclado USB HID e o usaremos para enviar pressionamentos de tecla ao PC. Esta biblioteca precisa de algumas mudanças para ser compatível com attiny85
• biblioteca tinytuner somente se você não usar um cristal de 16Mhz. Você precisará então calibrar o relógio interno do microcontrolador. Esta biblioteca funciona fora da caixa.
• Biblioteca Attiny-IR para interagir com o sensor IR. Esta biblioteca funciona fora da caixa.

Precisamos também de 2 bootloaders:

• Versão Dog Software, com interface serial disponível. Este bootloader precisa de um pequeno ajuste para funcionar com o attiny85, pois ele usa o timer1 para a função millis () e não funcionará com a biblioteca IR. Precisamos mudar o cronômetro para timer0.
• Versão Mellis, bootloader estável que usaremos na fase final. Isso funciona fora da caixa.

Etapa 5: Instalação e configuração da biblioteca V-usb

Baixe a biblioteca em https://code.google.com/archive/p/vusb-for-arduin… Descompacte o arquivo e copie a pasta libraries / UsbKeyboard para a pasta de bibliotecas do bloco de desenho.

Agora você precisa editar alguns arquivos para serem compatíveis com o ATtiny85 (ele está configurado para funcionar com o arduino):

A) edite usbconfig.h:

na alteração "Configuração de hardware":

#define USB_CFG_IOPORTNAME Dto ## define USB_CFG_IOPORTNAME B

e

#define USB_CFG_DMINUS_BIT 4to # define USB_CFG_DMINUS_BIT 0

na alteração "Configuração de hardware opcional":

#define USB_CFG_PULLUP_IOPORTNAME Dto ## define USB_CFG_PULLUP_IOPORTNAME B

Para criar uma especificação completa de "HID compatível com inicialização" (caso contrário, nenhuma chave de multimídia funcionará), altere também:

#define USB_CFG_INTERFACE_SUBCLASS 0 // Bootto # define USB_CFG_INTERFACE_SUBCLASS 0x01 // Boot

e

#define USB_CFG_INTERFACE_PROTOCOL 0 // Teclado para # define USB_CFG_INTERFACE_PROTOCOL 0x01 // Teclado

Opcionalmente, você também pode alterar o fabricante e o nome do dispositivo nas seguintes definições:

#define USB_CFG_VENDOR_NAME

#define USB_CFG_DEVICE_NAME

B) editar UsbKeyboard.h:

mudança:

PORTD = 0; // TODO: Apenas para pinos USB? DDRD | = ~ USBMASK;

para

PORTB = 0; // TODO: Somente para pinos USB? DDRB | = ~ USBMASK;

Para permitir a alteração de códigos-chave além de 101:

0x25, 0x65, // LOGICAL_MAXIMUM (101) para: 0x25, 0xE7, // LOGICAL_MAXIMUM (231)

e

0x29, 0x65, // USAGE_MAXIMUM (aplicativo de teclado) para: 0x29, 0xE7, // USAGE_MAXIMUM (aplicativo de teclado)

Pode ser necessário editar também estes 3 arquivos:

usbdrv.husbdrv.cUsbKeyboard.h

e toda vez que você vir PROGMEM adicione "const" antes do nome do tipo de variável (ex: PROGMEN char usbHidReportDescriptor [35] ==> PROGMEM const char usbHidReportDescriptor [35])

Se isso não estiver claro, visite

Você pode evitar todas essas alterações se apenas baixar a biblioteca anexada (eu mesmo fiz todas essas alterações) e apenas extraí-la dentro da pasta de bibliotecas do seu bloco de desenho:

UsbKeyboard configurado para attiny85

Edit: recentemente descobri que Alejandro Leiva (https://github.com/gloob) cuidou desta biblioteca e parece funcionar bem também. Você também pode experimentar a versão dele com as alterações necessárias que eu fiz para que funcione com o attiny, então se você quiser conferir basta extraí-lo dentro da pasta de bibliotecas do seu caderno de desenho.

UsbKeyboard configurado para attiny85 (versão Alejandro Leiva)

Etapa 6: instalação das bibliotecas Attiny-IR e Tinytuner

A) Biblioteca Attiny-IR:

baixe-o em https://drive.google.com/open?id=0B_w9z88wnDtFNHlq… então descompacte-o na pasta de bibliotecas do bloco de desenho.

B) Biblioteca Tinytuner:

Isso só é necessário se você não estiver usando um cristal de 16 MHz, mas acredite, mesmo que funcione também sem o cristal, é muito mais estável com ele e custam alguns centavos, então mantenha as coisas simples, use um cristal e pule esta biblioteca.

Ainda não está convencido? ok, baixe a biblioteca emhttps://storage.googleapis.com/google-code-archive … então descompacte-a na pasta de bibliotecas do bloco de desenho.

Concluímos as bibliotecas, agora passamos para a instalação dos gerenciadores de inicialização.

Etapa 7: Instalação e configuração dos carregadores de inicialização

Vamos instalar dois bootloaders, o Mellis, segundo minha experiência, é mais estável e vamos usá-lo no esboço final. O outro desenvolvido pela Rowdy Dog Software é um núcleo incrível, muito pequeno e com uma interface serial integrada disponível, mas meu controle remoto travou depois de algum tempo, então usaremos este bootloader apenas para calibrar o relógio interno attiny85 e decodificar nosso controle remoto botões.

Eu sei que existem bibliotecas disponíveis para dar aos recursos seriais attiny85, mas então você precisará ajustar as bibliotecas que usam o objeto serial … Eu gosto mais desse procedimento.

Vamos começar com a instalação:

A) Bootloader Mellis:

basta abrir as preferências do Arduino IDE e adicionar os URLs adicionais do gerenciador de placas:

raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

Em seguida, abra o gerenciador de placas IDE do Arduino e procure attiny, instale as placas do Mellis. Agora você deve ver o ID do Arduino das placas ATtiny25 / 45/85 e ATtiny24 / 44/84.

B) Carregador de inicialização minúsculo do Rowdy Dog Software:

baixe o bootloader em

Descompacte o arquivo e copie a pequena pasta dentro do seu caderno / hardware (crie esta pasta se ainda não existir). em seguida, vá para a pasta sketchbook / hardware / tiny / avr / e:

1) copie o arquivo Prospective Boards.txt para o arquivo boards.txt

2) edite o arquivo platform.txt e faça algumas alterações:

Remova o comentário da variável compiler.path e deixe-o apontando para a pasta hardware / tools / avr / bin / dentro da pasta de instalação do Arduino:

compiler.path = {PATH_TO_YOUR_ARDUINO_FOLDER} / hardware / tools / avr / bin /

alterar alsocompiler. S.flags = -c -g -assembler-with-cpptocompiler. S.flags = -c -g -x assembler-with-cpp

Em seguida, altere as seguintes variáveis certificando-se de que tudo está em seu lugar (esses arquivos devem existir, caso contrário, aponte as variáveis para os caminhos corretos):

tools.avrdude.cmd.path = {runtime.ide.path} / hardware / tools / avr / bin / avrdude

tools.avrdude.config.path = {runtime.ide.path} /hardware/tools/avr/etc/avrdude.conf

tools.avrdude.cmd.path.linux = {runtime.ide.path} / hardware / tools / avr / bin / avrdude

tools.avrdude.config.path.linux = {runtime.ide.path} /hardware/tools/avr/etc/avrdude.conf

3) edite o arquivo núcleos / tiny / core_build_options.he mude:

#define TIMER_TO_USE_FOR_MILLIS 1 a # define TIMER_TO_USE_FOR_MILLIS 0

Isso é muito importante, caso contrário, o receptor IR emitirá zeros para cada botão. Esta instrução configura o timer0 para a função millis (), deixando o timer1 disponível para a biblioteca IR. O esboço final desativará o timer0 de qualquer maneira, então você não terá as funções millis () e delay () disponíveis. Você pode ter a função delayMicroseconds () disponível em vez disso.

Este carregador de inicialização é mínimo, mas inclui suporte para objeto serial:

Attiny85 PB2 (pin7) é TX e PB0 (pin5) é RX

Você pode ter uma configuração com o programador ISP (arduino) e o adaptador serial para USB conectado ao mesmo tempo, então você não precisa trocar os fios com muita frequência:

Agora que temos as bibliotecas e os gerenciadores de inicialização instalados e configurados corretamente, o trabalho mais difícil está concluído e podemos começar a testar as coisas.

Etapa 8: Gravando Bootloaders e Enviando Sketches

Aconselho fortemente ativar a saída detalhada nas preferências do IDE do Arduino para que você possa descobrir qualquer problema eventual.

Para gravar um bootloader no Attiny85, você precisa fazer o upload do exemplo do ISP para o Arduino e, em seguida, selecionar o programador Arduino como ISP.

Agora coloque um capacitor de 10uF entre os pinos de reset e aterramento no arduino (não é necessário para o processo de gravação, mas para fazer o upload dos esboços para o attiny85).

Agora o arduino está pronto para queimar bootloaders e carregar esboços. Você só precisa selecionar a placa certa compatível com o seu attiny e queimá-la.

Para carregar um sketch no Attiny85, carregue-o no IDE do arduino e clique em "Upload using programmer".

IMPORTANTE: ao fazer o upload do esboço, existem 3 etapas, compilação, redação e verificação. Se a compilação e a escrita funcionaram com sucesso, mas o processo de verificação falha, é possível que o esboço funcione de qualquer maneira.

Etapa 9: Calibre o relógio interno Attiny85 (pule isto se você usar um cristal)

Caso você decida não usar o cristal de 16Mhz, você precisa calibrar seu relógio attiny85, então vamos precisar de um bootloader com uma interface serial disponível e usaremos a biblioteca do tinytuner para obter a calibração correta.

Siga as próximas etapas

• selecione em ferramentas o Arduino como programador ISP
• selecione a placa "ATtiny85 @ 8MHz (oscilador interno; BOD desabilitado)"
• Presumo que você tenha a conexão ISP pronta conforme descrito antes de conectar, caso contrário, faça as conexões
• queimar bootloader
• este bootloader configurou pinos diferentes para a interface serial, use esta configuração apenas para o bootloader atual

- PB4 (pin3 RX) para TX no FT232RL attiny85 - PB3 (pin2 TX) para RX no FT232RL attiny85 - GND (pin4) para GND no FT232RL uma vez que o attiny85 já é alimentado pelo arduino você não precisa conectar os 5 V no FT232RL, caso contrário, conecte: attiny85 VCC (pino 8) a 5 V no FT232RL

• carregue o exemplo do tinytuner para o attiny85
• abra o programa de tela para monitorar a comunicação serial: screen / dev / ttyUSB0 9600
• redefina o attiny85 conectando o pino RESET (pino 1) ao GND (apenas um momento), uma mensagem de boas-vindas deve ser exibida na janela da tela
• Continue enviando caracteres 'x' únicos (sem retorno de carro; sem avanço de linha) até que a calibração termine
• anote em algum lugar o valor da calibração (OSCCAL = 0x). Este é o valor que você precisará declarar nos esboços finais

Etapa 10: decodifique seus botões remotos

Agora é hora de decodificar nossos botões remotos e atribuí-los a pressionamentos de tecla específicos no PC, para fazer isso siga as próximas etapas:

• selecione a placa "ATtiny85 @ 16MHz (PLL interno; 4.3V BOD)" se você não usar um cristal, "ATtiny85 @ 16 MHz (cristal externo; 4.3 V BOD" caso contrário, queime-o
• carregue o esboço:
• Se você não usar um cristal, descomente a linha que contém a variável OSCCAL e atribua-a ao valor que você encontrou quando fez a calibração do relógio
• Presumo que o sensor esteja conectado conforme descrito antes, caso contrário, conecte-o
• Presumo também que o adaptador FT232RL serial para USB está conectado, caso contrário, conecte-o
• reinicie o attiny85 conectando o pino RESET (pino 1) ao GND (apenas um momento)
• aperte repetidamente os botões do seu controle remoto e verifique a janela da tela, você precisa anotar o último número para cada registro, cada botão pode produzir 2 números diferentes

Exemplo:

RECEBIDO D44 3396 RECEBIDO 544 1348

Anote 3396 e 1348 em associação com o botão que acabou de apertar e, em seguida, você deve decidir o que deseja fazer com esse botão. Por exemplo, eu poderia querer que esse botão enviasse o código-chave de multimídia "Aumentar volume", então preciso encontrar a ID desse código-chave. Para fazer isso, baixe o PDF:

Consulte a seção "Página do teclado / teclado numérico" na página 53 e use os números na coluna ID de uso (dezembro) para vincular seus botões remotos aos códigos do teclado. Em nosso exemplo, podemos ver que o código-chave para "Aumentar o volume" é: 128.

Edite o arquivo UsbKeyboard.h dentro da biblioteca UsbKeyboard do pacote v-usb que instalamos antes e adicione às definições existentes se ainda não estiver lá:

# define KEY_VOL_UP 128

Quando terminarmos de usar todos os nossos botões / s remotos e todas as definições no arquivo UsbKeyboard.h estiverem prontas, podemos passar para a última etapa.

Etapa 11: Carregando o esboço final e espero o melhor

Agora temos todos os botões remotos decodificados, o arquivo UsbKeyboard.h é preenchido com nossos códigos de tecla, então agora podemos carregar no IDE do arduino o esboço definitivo de:

github.com/venumz/ATtiny85-USB-IR-receiver…

Este arquivo é o arquivo exato que estou usando para o meu receptor e está funcionando para 2 controles remotos diferentes, então é claro que você precisa atualizá-lo para trabalhar com o (s) seu (s) controle (s).

Se você não usar um cristal, descomente a linha que contém a variável OSCCAL e atribua-a ao valor que você encontrou quando fez a calibração do relógio

Observe que na função de loop existem muitas instruções como esta:

if (results.value == 3405 || results.value == 1357) {// seta para cima

if (lastStroke! = results.value) UsbKeyboard.sendKeyStroke (KEY_ARROW_UP);

}

Você deve criar suas próprias declarações, uma por botão em seu controle remoto. Na condição "if" você deve colocar em results.value os valores que você encontrou decodificando seu controle remoto e como argumento do método UsbKeyboard.sendKeyStroke você deve colocar um dos keycodes já definidos no arquivo UsbKeyboard.h.

A condição "if (lastStroke! = Results.value)" é necessária porque alguns remotos enviam o mesmo código duas vezes por hit e isso evita o segundo hit. Não estou totalmente certo e pode depender do protocolo IR que foi programado em seu controle remoto (não sou realmente um especialista em protocolos de IR), mas de acordo com minha experiência com meus próprios controles remotos, cada botão pode produzir 2 códigos diferentes e enquanto você pressiona e segura o botão, ele envia o mesmo código, mas se você apertar o botão novamente, ele envia o outro. Portanto, parece que os códigos são enviados de forma alternada, acho que é um modo padrão saber quantas vezes você realmente aperta o botão.

Ok, estamos quase terminando, basta fazer o upload do esboço final, conectá-lo ao PC e ver como fica.

Para esta etapa, é melhor se você desconectar o arduino e o USB do adaptador serial e só então, conectar o USB na porta do seu PC (caso algo dê errado, seu circuito será mais simples de depurar).

Se tudo funcionou bem, ao abrir um terminal e enviar o comando dmesg, você verá algo semelhante à primeira imagem nesta etapa. Se houver problemas, você deve ter erros como os encontrados na segunda imagem e deve começar a depurar seu circuito e / ou software. Uma das fontes dos erros iniciais que tive foi um hub USB que não funcionava com meu receptor IR (outros funcionaram) … então é melhor para esta etapa final conectar o receptor IR diretamente à porta do seu PC. Eventuais erros podem ser difíceis de encontrar, mas no final, como eu, você aprenderia muito e o preço a pagar vale a pena, garanto.

Isso é tudo pessoal, deixe-me saber se você notar algum erro neste instrutível e aproveite seu novo receptor USB IR!