ATtiny85 IR USB-ontvanger - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

WAARSCHUWING, DIT INSTRUCTEERBAAR IS VEROUDERD

De v-usb-bibliotheek is ontworpen om te werken met het USB 1.1-protocol dat tegenwoordig nauwelijks bestaat. Met de komst van USB3 heb je meer dan hoofdpijn als je probeert om v-usb-apparaten te laten werken. Na het veranderen van mijn multimediacentrum heb ik veel stabiliteitsproblemen en hoewel de ontvanger werkt, stopt hij na een tijdje met werken. Het is me niet gelukt om het te repareren. Ik heb ook een atmega328p-versie gemaakt, maar deze had dezelfde problemen. Het gebruik van een watchdog-timer om het bord periodiek te resetten hielp ook niet, dus ik gaf v-usb op.

Doe jezelf een plezier en ga niet door met dit instructable tenzij het voor educatieve doeleinden is. Ik raad aan om in plaats daarvan een chipmodule ATmega 32U4 te kopen die de usb-interface al heeft geïntegreerd en deze handleiding te volgen:

www.sparkfun.com/tutorials/337

Gooi er dan een IR-sensor TSOP31238 in en je bent klaar om te gaan.

Hallo makers! dit is een instructie om een werkende USB IR-ontvanger te bouwen met behulp van een Attiny85-microcontroller. Ik begon dit project om het gebrek aan ondersteuning (ten minste volledige ondersteuning) voor sommige IR-afstandsbedieningen in het GNU/Linux-besturingssysteem te verhelpen. Door deze instructies te volgen, zou je voor een paar dollar een programmeerbare USB IR-ontvanger kunnen bouwen die met elke IR-afstandsbediening werkt.

Allereerst zou deze instructable niet bestaan zonder het harde werk van de mensen die de bibliotheken hebben gemaakt die ik hier gebruik:

• David A. Mellis voor zijn attiny-kern
• Rowdy Dog Software voor hun bibliotheek TinyTuner
• Rowdy Dog-software voor hun kleine bootloader
• Rancidbacon (https://rancidbacon.com/) voor zijn arduino-poort van de v-usb-bibliotheek (https://code.google.com/archive/p/vusb-for-arduino/downloads)
• seejaydee voor zijn IR-bibliotheek voor kleine kernen gevonden op de opmerkingen van de instructable https://www.instructables.com/id/Attiny-IR-librar… code op https://www.instructables.com/id/Attiny-IR -bibliothecaris…

Soms is het niet gemakkelijk om de juiste eigenaar van een bibliotheek te vinden, dus als ik een fout heb gemaakt, laat dan een reactie achter en ik zal het probleem zo snel mogelijk oplossen.

Deze gids bestaat omdat ik geen complete tutorial/gids heb gevonden die direct uit de doos werkt (deze bestaat misschien, maar ik kon hem niet vinden), dus ik verzamelde alle informatie die beschikbaar was op internet en na een flink aantal proeven en errors Ik bedacht een complete gids om een werkende USB IR-ontvanger te bouwen die eigenlijk best goed werkt.

De belangrijkste informatiebronnen die ik heb gevolgd:

• 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…

Stap 1: Enkele overwegingen

• Ik heb geen AVR ISP-programmeur en ik heb niet echt zin om er een te kopen, dus ik heb een Arduino gebruikt om de attiny85 te programmeren
• Ik geef niets om een ander besturingssysteem dan GNU/Linux, dus ik weet niet of dit anders gaat werken.
• er zijn andere IR-bibliotheken, maar ik kon ze niet laten werken, zelfs niet met een arduino. Bedenk echter dat ik begon met een beperkte kennis over IR-bibliotheken. Misschien zou ik ze nu kunnen laten werken na de ervaring die ik heb opgedaan met het omgaan met een behoorlijk aantal problemen. Hoe dan ook, ik was verdwaald en wanhopig voordat ik de bibliotheek vond die Seejaydee ter beschikking stelde en die heb ik sindsdien gebruikt (heel erg bedankt man!).
• Er zijn andere hardwareconfiguraties, maar ik heb alleen degene gebruikt die 5V gebruikt om de attiny85 van stroom te voorzien en twee 3.6V 0.5W zenerdiodes om de spanning van de datalijnen vast te klemmen, het werkt uit de doos, dus ik heb er niet mee geknoeid andere configuraties.
• U kunt een 16Mhz-kristal gebruiken of u kunt de tinytuner-bibliotheek gebruiken om de interne klok van uw attiny85 te kalibreren. Ik raad het gebruik van het kristal ten zeerste aan, het is veel stabieler en zal je waarschijnlijk veel hoofdpijn besparen.
• Ik gebruik hier twee verschillende bootloaders voor de attiny85:

a) Rowdy Dog Software-versie, het heeft een seriële interface geïntegreerd die erg cool is en erg klein is, zodat je meer ruimte hebt voor je programma en andere bibliotheken. Het probleem is dat om de een of andere reden, hoewel het redelijk goed werkt, het USB-apparaat na enige tijd werd losgekoppeld (je kunt de problemen vinden met het commando dmesg). Ik weet niet of dit een probleem is van de kern of een gemengde combinatie van de kern plus de gekozen bibliotheken, dus na een tijdje besloot ik deze kern te gebruiken alleen om de afstandsbedieningen te decoderen en de klok te kalibreren (wanneer ik geen 16Mhz kristal). Daarna brand ik gewoon de Mellis-bootloader en upload ik de definitieve schets die de seriële interface niet gebruikt.

b) Mellis-versie, stabiele bootloader, ik heb dit in veel projecten gebruikt. Ik zou deze bootloader altijd hebben gebruikt als hij een seriële interface had gehad. Ik gebruik deze kern in de uiteindelijke schets na het decoderen van alle toetsen op mijn afstandsbedieningen.

Stap 2: Laten we beginnen met de hardware

Gereedschap dat je nodig hebt:

• een arduino-compatibel bord
• een serieel naar usb-adapter om uw afstandsbedieningen te decoderen (gebruik gewoon een FT232RL)
• een pc met GNU/Linux geïnstalleerd en de arduino IDE correct geconfigureerd, ik gebruik arduino IDE 1.8.0
• een IR-afstandsbediening om je apparaat te testen (zelfs een waardeloze zoals die in Arduino-startpakketten zal werken)
• een multimeter om je bord te debuggen (ik hoop dat je het niet nodig hebt, veel succes!)

De lijst met materialen:

• 1 attiny85
• 2 68R-weerstanden
• 1 1.5K weerstand
• 1 4.7K weerstand
• 1 16Mhz kristal
• 1 22pF condensator
• 1 0.1uF condensator
• 1 10uF condensator
• 2 3.6V 0.5W zenerdiodes
• 1 USB type A mannelijke connector
• 1 strippen met 6 pinnen om het bord te programmeren en te debuggen.
• 1 IR-sensor TSOP31238
• veel koffie om je wakker te houden

Voordat je het definitieve bord gaat solderen, wil je waarschijnlijk een breadboard-prototype maken voor testdoeleinden, het volgen van het schema dat aan deze instructable is gekoppeld, zou voldoende moeten zijn om het op te bouwen.

Om de attiny85 op de pc aan te sluiten, gebruikt het uiteindelijke ontwerp een USB type A-connector die in het bord is gesoldeerd, maar voor het prototype moet je een USB-kabel maken die je op een breadboard kunt aansluiten:

Soldeer in een klein stukje perfboard 4 pinnen, knip dan een oude USB-kabel door en soldeer de pinnen aan 4 van de draden in de USB-kabel:

• rood is VCC (5V)
• zwart is GND
• wit is D-
• groen is D+

Houd alles bij elkaar met hete lijm.

Nu moeten we de ISP-programmeur (Arduino), de USB-naar-serieel-adapter (FT232RL) en de IR-sensor op de attiny85 aansluiten.

Je kunt alles met elkaar verbonden laten, zodat je verschillende bootloaders kunt branden, schetsen kunt laden en de seriële poort kunt bekijken zonder kabels te verwisselen, Sluit hiervoor alles aan volgens deze instructies:

ISP-programmeur (Arduino): hiermee kunnen we bootloaders branden en schetsen laden

• attiny85 PB0 (pin5) naar pin11 (MOSI) in arduino
• attiny85 PB1 (pin6) naar pin12 (MISO) in arduino
• attiny85 PB2 (pin7) naar pin13 (SCK) in arduino
• attiny85 RESET (pin1) met pullup (4,6k naar VCC) naar pin10 in arduino
• attiny85 VCC naar 5V in arduino
• attiny85 GND naar GND in arduino

usb naar seriële adapter (FT232RL): hiermee kunnen we de seriële poort controleren

• attiny85 PB0 (pin5 RX) naar TX in de FT232RL
• attiny85 PB2 (pin7 TX) naar RX in de FT232RL
• attiny85 GND (pin4) naar GND op de FT232RL
• aangezien de attiny85 al wordt gevoed door de arduino, hoeft u de 5v op de FT232RL niet aan te sluiten, anders sluit u: attiny85 VCC (pin8) aan op 5V op de FT232RL

usb naar seriële adapter (FT232RL) alleen voor de klokkalibratie (alleen voor de bootloader "ATtiny85 @ 8MHz (interne oscillator; BOD uitgeschakeld)")

• PB4 (pin3 RX) naar TX in de FT232RL attiny85
• PB3 (pin2 TX) naar RX in de FT232RL attiny85
• GND (pin4) naar GND op de FT232RL
• aangezien de attiny85 al wordt gevoed door de arduino, hoeft u de 5v op de FT232RL niet aan te sluiten, anders sluit u: attiny85 VCC (pin8) aan op 5V op de FT232RL

Als u een 16Mhz-kristal gebruikt, sluit deze dan aan op de Attiny85-pinnen PB3 (pin2) en PB4 (pin3) en verbind elke pin ook met GND via een 22pF-dop elk.

Filter Attiny85 VCC met een 0.1uF en 10uF condensatoren die ze parallel verbinden met GND

Sluit de uitgangspin van de IR-sensor aan op de attiny85 PB1 (pin6), zet hem aan.

Bouw en sluit de usb-interface aan:

• GND (zwarte draad): sluit deze aan op de gemeenschappelijke GND (alle aardingen zijn met elkaar verbonden)
• D- (witte draad) aangesloten op attiny85 PB0 (pin5) via een 68R-weerstand, sluit deze ook aan op aarde via een 3.6V 0.5W zener en trek het naar VCC met een 1.5K-weerstand
• D+ (groene draad) aangesloten op PB2 via een 68R-weerstand, verbind deze met aarde via een 3,6V 0,5W zener
• 5V, je kunt het niet aangesloten laten omdat alles in dit stadium wordt gevoed door de Arduino, sluit het anders aan op de attiny85 VCC

De zenerdiodes zijn zo aangesloten dat de anodes zijn verbonden met GND en de kathodes zijn verbonden met de datalijnen D+ en D-.

Stap 3: definitief ontwerp

Voor het uiteindelijke ontwerp kun je perfboard gebruiken met doorlopende gaten of je eigen bord etsen en smd-componenten gebruiken. Om te leren hoe je een bord kunt etsen, google het gewoon, er zijn geweldige tutorials online beschikbaar.

Ik heb mijn eigen bord geëtst en ik ben erg blij met het uiteindelijke resultaat (klein, stabiel en robuust bord). Ja, ik weet dat de snede zuigt, maar ik kon zo laat in de nacht geen elektrisch gereedschap gebruiken en ik knip het bord gewoon door met mijn blikschaar.

Trouwens, de sporen op de afbeeldingen zijn geen blank koper, ze zijn behandeld met een vervelende chemische stof die het koper lichtjes vertint (het wordt vermoed kanker te veroorzaken, dus gebruik het met grote zorg, latex globes en een stofmasker):

Gebruik de bovenstaande schema's om uw lay-out te ontwerpen of u kunt gewoon mijn pcb-voetafdruk gebruiken om uw bord te etsen.

Stap 4: Omgaan met de software

Het circuit in dit project is heel eenvoudig, de software vereist in plaats daarvan een grotere inspanning.

We hebben minimaal 2 bibliotheken nodig (nog één als je geen kristal gebruikt) plus 2 bootloaders om dit te laten werken. Toen ik aan dit project begon, heb ik een aantal bibliotheken getest, soms werkten ze niet en vaak waren ze gewoon niet geconfigureerd om te werken met een Attiny85 uit de doos (dat wist ik nog niet). Toen vond ik problemen met de overlappende interrupts van bibliotheken / bootloaders. Uiteindelijk kreeg ik behoorlijk wat fouten te verwerken toen ik de laatste schakeling op mijn pc aansloot. Ik had deze handleiding echter niet, dus ik denk dat het goed zou komen, volg gewoon de stappen in deze instructable, als je dat doet zonder fouten te maken, zou het goed moeten komen:)

We moeten nu een paar bibliotheken installeren en configureren:

• v-usb voor arduino-bibliotheek: met deze bibliotheek kan de microcontroller door de pc worden herkend als een HID USB-toetsenbord, en we zullen het gebruiken om toetsaanslagen naar de pc te sturen. Deze bibliotheek heeft enkele wijzigingen nodig om compatibel te zijn met de attiny85
• tinytuner-bibliotheek alleen als u geen 16Mhz-kristal gebruikt. U moet dan de interne klok van de microcontroller kalibreren. Deze bibliotheek werkt out-of-the-box.
• Attiny-IR-bibliotheek voor interactie met de IR-sensor. Deze bibliotheek werkt out-of-the-box.

We hebben ook 2 bootloaders nodig:

• Dog Softwareversie, met de seriële interface beschikbaar. Deze bootloader heeft een kleine aanpassing nodig om met de attiny85 te werken, aangezien deze de timer1 gebruikt voor de millis()-functie en niet zal werken met de IR-bibliotheek. We moeten de timer veranderen in timer0.
• Mellis-versie, stabiele bootloader die we in de laatste fase zullen gebruiken. Dit werkt out-of-the-box.

Stap 5: Installatie en configuratie van de V-usb-bibliotheek

Download de bibliotheek van https://code.google.com/archive/p/vusb-for-arduin… Pak het bestand uit en kopieer de map bibliotheken/UsbKeyboard naar de map met schetsboekbibliotheken.

Nu moet je een aantal bestanden bewerken om compatibel te zijn met de ATtiny85 (deze is geconfigureerd om met arduino te werken):

A) bewerk usbconfig.h:

onder "Hardwareconfiguratie" wijzigen:

#define USB_CFG_IOPORTNAME Dnaar##define USB_CFG_IOPORTNAME B

en

#define USB_CFG_DMINUS_BIT 4naar#define USB_CFG_DMINUS_BIT 0

onder "Optionele hardwareconfiguratie" wijzigen:

#define USB_CFG_PULLUP_IOPORTNAME Dnaar##define USB_CFG_PULLUP_IOPORTNAME B

Om een volledige "boot-compatibele HID"-specificatie te maken (anders werken geen multimediatoetsen), wijzigt u ook:

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

en

#define USB_CFG_INTERFACE_PROTOCOL 0 // Toetsenbordnaar#define USB_CFG_INTERFACE_PROTOCOL 0x01 // Toetsenbord

Optioneel kunt u ook de fabrikant en de apparaatnaam wijzigen in de volgende definities:

#define USB_CFG_VENDOR_NAME

#define USB_CFG_DEVICE_NAME

B) bewerk UsbKeyboard.h:

verandering:

POORT = 0; // TODO: Alleen voor USB-pinnen? DDRD |= ~USBMASK;

tot

POORTB = 0; // TODO: Alleen voor USB-pinnen? DDRB |= ~USBMASK;

Om keycodes hoger dan 101 toe te staan, wijzigt u ook:

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

en

0x29, 0x65, // USAGE_MAXIMUM (toetsenbordtoepassing)naar:0x29, 0xE7, // USAGE_MAXIMUM (toetsenbordtoepassing)

Mogelijk moet u ook deze 3 bestanden bewerken:

usbdrv.husbdrv.cUsbKeyboard.h

en elke keer dat je PROGMEM ziet, voeg je "const" toe voor de naam van het variabele type (bijvoorbeeld: PROGMEN char usbHidReportDescriptor[35] ==> PROGMEM const char usbHidReportDescriptor[35])

Als dit niet duidelijk is, bezoek dan

U kunt al deze wijzigingen vermijden als u gewoon de bijgevoegde bibliotheek downloadt (ik heb al deze wijzigingen zelf aangebracht) en deze gewoon uitpakt in uw map met schetsboekbibliotheken:

UsbKeyboard geconfigureerd voor attiny85

Bewerken: onlangs heb ik ontdekt dat Alejandro Leiva (https://github.com/gloob) voor deze bibliotheek is gezorgd en ook goed lijkt te werken. Je kunt zijn versie ook proberen met de nodige wijzigingen die ik heb aangebracht om het te laten werken met de attiny, dus als je dit wilt bekijken, pak je het gewoon uit in je map met schetsboekbibliotheken.

UsbKeyboard geconfigureerd voor attiny85 (Alejandro Leiva-versie)

Stap 6: Installatie van de Attiny-IR- en Tinytuner-bibliotheken

A) Attiny-IR-bibliotheek:

download het van https://drive.google.com/open?id=0B_w9z88wnDtFNHlq… en pak het vervolgens uit in de map met schetsboekbibliotheken.

B) Tinytuner-bibliotheek:

Dit is alleen nodig als je geen 16Mhz kristal gebruikt, maar geloof me, ook al werkt het ook zonder het kristal, het is veel stabieler ermee en ze kosten een paar cent, dus houd het simpel, gebruik een kristal en sla over deze bibliotheek.

Nog niet overtuigd? ok, download de bibliotheek van https://storage.googleapis.com/google-code-archive … en pak het vervolgens uit in de map met schetsboekbibliotheken.

We zijn klaar met de bibliotheken, nu gaan we verder met het installeren van de bootloaders.

Stap 7: Installatie en configuratie van de Bootloaders

We gaan twee bootloaders installeren, de Mellis is volgens mijn ervaring stabieler en we zullen deze gebruiken in de uiteindelijke schets. De andere ontwikkeld door Rowdy Dog Software is een geweldige kern, erg klein en met een geïntegreerde seriële interface beschikbaar, maar mijn afstandsbediening crashte na enige tijd ermee, dus we zullen deze bootloader gebruiken om de interne klok van attiny85 te kalibreren en om onze afstandsbediening te decoderen toetsen.

Ik weet dat er bibliotheken beschikbaar zijn om de attiny85 seriële mogelijkheden te geven, maar dan moet je de bibliotheken aanpassen die het seriële object gebruiken … Ik vind deze procedure beter.

Laten we beginnen met de installatie:

A) Mellis-bootloader:

open gewoon de Arduino IDE-voorkeuren en voeg de Extra Boards Manager-URL's toe:

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

Open vervolgens de Arduino IDE boards manager en zoek naar attiny, installeer de boards van Mellis. Nu zou je de Arduino ID de ATtiny25/45/85 en ATtiny24/44/84 boards moeten zien.

B) Rowdy Dog Software kleine bootloader:

download de bootloader van

Pak het bestand uit en kopieer de kleine map in je schetsboek/hardware (maak deze map aan als deze nog niet bestaat). ga dan naar de map sketchbook/hardware/tiny/avr/ en:

1) kopieer het bestand Prospective Boards.txt naar het bestand boards.txt

2) bewerk het bestand platform.txt en breng enkele wijzigingen aan:

Uncommenteer de variabele compiler.path en laat het wijzen naar de map hardware/tools/avr/bin/ in je arduino-installatiemap:

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

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

Wijzig vervolgens de volgende variabelen en zorg ervoor dat alles op zijn plaats staat (die bestanden moeten bestaan, anders wijst u de variabelen naar de juiste paden):

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) bewerk het bestand cores/tiny/core_build_options.h en verander:

#define TIMER_TO_USE_FOR_MILLIS 1 tot #define TIMER_TO_USE_FOR_MILLIS 0

Dit is erg belangrijk, anders geeft de IR-ontvanger nullen af voor elke knop. Deze instructie configureert timer0 voor de functie millis() en laat timer1 beschikbaar voor de IR-bibliotheek. De laatste schets zal de timer0 hoe dan ook uitschakelen, dus je hebt geen millis() en delay() functies. Mogelijk hebt u in plaats daarvan een beschikbare delayMicroseconds()-functie.

Deze bootloader is minimaal, maar heeft ondersteuning voor seriële objecten:

Attiny85 PB2 (pin7) is TX en PB0 (pin5) is RX

U kunt een configuratie hebben waarbij de ISP-programmeur (arduino) en de serieel naar usb-adapter tegelijkertijd zijn aangesloten, zodat u niet te vaak van draad hoeft te wisselen:

Nu hebben we zowel de bibliotheken als de bootloaders geïnstalleerd en correct geconfigureerd, het hardste werk is voltooid en we kunnen beginnen met het testen van dingen.

Stap 8: Bootloaders branden en schetsen uploaden

Ik raad ten zeerste aan om de uitgebreide uitvoer onder de Arduino IDE-voorkeuren te activeren, zodat je eventuele problemen kunt achterhalen.

Om een bootloader in de Attiny85 te branden, moet je het ISP-voorbeeld uploaden naar de Arduino en vervolgens de programmer Arduino als ISP selecteren.

Plaats nu een 10uF-condensator tussen de reset- en grondpinnen op de arduino (het is niet nodig voor het brandproces, maar het is om schetsen naar de attiny85 te uploaden).

Nu is de arduino klaar om bootloaders te branden en schetsen te laden. Je hoeft alleen maar het juiste bord te selecteren dat compatibel is met je attiny en het te branden.

Om een schets in de Attiny85 te laden, laadt u deze in de arduino IDE en klikt u op "Uploaden met programmer".

BELANGRIJK: bij het uploaden van de schets zijn er 3 stappen, compileren, schrijven en verifiëren. Als het compileren en schrijven wel gelukt is, maar het verificatieproces mislukt, is het mogelijk dat de schets toch zou werken.

Stap 9: Kalibreer de Attiny85 interne klok (sla dit over als u een kristal gebruikt)

Als je besluit om het 16Mhz-kristal niet te gebruiken, moet je je attiny85-klok kalibreren, dus we hebben een bootloader nodig met een beschikbare seriële interface en we zullen de tinytuner-bibliotheek gebruiken om de juiste kalibratie te krijgen.

Volg de volgende stappen

• selecteer onder tools de Arduino als ISP programmeur
• selecteer het bord "ATtiny85 @ 8MHz (interne oscillator; BOD uitgeschakeld)"
• Ik neem aan dat je de ISP-verbinding gereed hebt zoals beschreven voordat verbinding wordt gemaakt, anders doe je de verbindingen
• bootloader branden
• deze bootloader heeft verschillende pinnen geconfigureerd voor de seriële interface, gebruik deze configuratie alleen voor de huidige bootloader

- PB4 (pin3 RX) naar TX in de FT232RL attiny85 - PB3 (pin2 TX) naar RX in de FT232RL attiny85 - GND (pin4) naar GND op de FT232RL aangezien de attiny85 al wordt aangedreven door de arduino die u niet hoeft aan te sluiten de 5v op de FT232RL, sluit anders aan: attiny85 VCC (pin8) op 5V op de FT232RL

• upload het tinytuner-voorbeeld naar de attiny85
• open het schermprogramma om de seriële communicatie te controleren: screen /dev/ttyUSB0 9600
• reset de attiny85 door de RESET-pin (pin1) te verbinden met GND (een ogenblik), een welkomstbericht zou op het schermvenster moeten verschijnen
• Ga door met het verzenden van enkele 'x'-tekens (geen regelterugloop; geen regelinvoer) totdat de kalibratie is voltooid
• annoteer ergens de waarde van de kalibratie (OSCCAL = 0x). Dit is de waarde die u moet aangeven op de definitieve schetsen

Stap 10: Decodeer uw afstandsbedieningsknoppen

Nu is het tijd om onze afstandsbedieningsknoppen te decoderen en ze toe te wijzen aan specifieke toetsaanslagen op de pc, volg hiervoor de volgende stappen:

• selecteer het bord "ATtiny85 @ 16MHz (interne PLL; 4.3V BOD)" als je geen kristal gebruikt, anders "ATtiny85 @ 16 MHz (extern kristal; 4.3 V BOD) en verbrand het dan
• laad de schets:
• Als je geen kristal gebruikt, verwijder dan het commentaar van de rij die de OSCCAL-variabele bevat en wijs deze toe aan de waarde die je hebt gevonden toen je de klok kalibreerde
• Ik neem aan dat de sensor is aangesloten zoals eerder beschreven, anders sluit ik hem aan
• Ik ga er ook vanuit dat de FT232RL serieel naar usb adapter is aangesloten, anders sluit ik hem aan
• reset de attiny85 door de RESET-pin (pin1) te verbinden met GND (even)
• druk herhaaldelijk op de knoppen van je afstandsbediening en check het schermvenster, je moet het laatste nummer voor elke record annoteren, elke knop kan 2 verschillende nummers produceren

Voorbeeld:

ONTVANGEN D44 3396 ONTVANGEN 544 1348

Annoteer 3396 en 1348 in associatie met de knop die je zojuist hebt ingedrukt, dan moet je beslissen wat je met die knop wilt doen. Ik zou bijvoorbeeld willen dat die knop de multimediasleutelcode "Volume omhoog" verzendt, dan moet ik de ID voor die sleutelcode vinden. Download hiervoor de PDF:

Kijk uit voor sectie "Toetsenbord/Toetsenblokpagina" pagina 53 en gebruik de cijfers in de kolom Gebruiks-ID (dec) om uw afstandsbedieningstoetsen te koppelen aan toetsenbordcodes. In ons voorbeeld kunnen we zien dat de sleutelcode voor "Volume omhoog" is: 128.

Bewerk het bestand het bestand UsbKeyboard.h in de UsbKeyboard-bibliotheek van het v-usb-pakket dat we eerder hebben geïnstalleerd en voeg toe aan de bestaande definities als het er nog niet is:

#define KEY_VOL_UP 128

Als we klaar zijn met al onze afstandsbediening/s-knoppen en alle definities in het bestand UsbKeyboard.h klaar zijn, kunnen we naar de laatste stap gaan.

Stap 11: Laden van de definitieve schets en hopen op het beste

We hebben nu alle knoppen op afstand gedecodeerd, het bestand UsbKeyboard.h is gevuld met onze keycodes, dus nu kunnen we de definitieve schets in de Arduino IDE laden van:

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

Dit bestand is het exacte bestand dat ik gebruik voor mijn ontvanger, en het werkt voor 2 verschillende afstandsbedieningen, dus het is duidelijk dat je het moet bijwerken om met je afstandsbediening(en) te kunnen werken.

Als je geen kristal gebruikt, verwijder dan het commentaar van de rij die de OSCCAL-variabele bevat en wijs deze toe aan de waarde die je hebt gevonden toen je de klok kalibreerde

Merk op dat er in de lusfunctie veel uitspraken zijn zoals deze:

if(results.value==3405 || results.value==1357) { // pijl omhoog

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

}

U moet uw eigen verklaringen maken, één per knop op uw afstandsbediening. In de "if" conditie moet je in de results.value de waarden zetten die je gevonden hebt bij het decoderen van je remote en als argument van de UsbKeyboard.sendKeyStroke methode moet je een van de reeds gedefinieerde keycodes in het bestand UsbKeyboard.h zetten.

De voorwaarde " if(lastStroke!=results.valu) " is nodig omdat sommige afstandsbedieningen dezelfde code twee keer per treffer verzenden, en dit voorkomt de tweede treffer. Ik weet het niet helemaal zeker en het kan afhangen van het IR-protocol dat in uw afstandsbediening is geprogrammeerd (ik ben niet echt een expert in IR-protocollen) maar volgens mijn ervaring met mijn eigen afstandsbedieningen kan elke knop 2 verschillende codes produceren en terwijl je de knop ingedrukt houdt, wordt dezelfde code verzonden, maar als je nogmaals op de knop drukt, wordt de andere verzonden. Het lijkt er dus op dat de codes op een alternatieve manier worden verzonden, ik denk dat het een standaardmodus is om te weten hoe vaak je echt op de knop drukt.

Ok, we zijn bijna klaar, upload de definitieve schets, sluit hem aan op de pc en kijk hoe het gaat.

Voor deze stap is het beter als u zowel de arduino als de usb-naar-serieel-adapter loskoppelt en pas dan de USB in uw pc-poort steekt (in het geval dat er iets misgaat, is uw circuit eenvoudiger te debuggen).

Als alles goed werkte, zou je bij het openen van een terminal en het verzenden van de opdracht dmesg iets moeten zien dat lijkt op de eerste afbeelding in deze stap. Als er problemen waren, zou u fouten moeten hebben zoals die in de tweede afbeelding en moet u beginnen met het debuggen van uw circuit en/of de software. Een van de oorzaken van de eerste fouten die ik had, was een USB-hub die niet zou werken met mijn IR-ontvanger (andere werkten wel) … dus het is beter voor deze laatste stap om de IR-ontvanger rechtstreeks op uw pc-poort aan te sluiten. Eventuele fouten kunnen moeilijk te vinden zijn, maar uiteindelijk zou je, net als ik, veel leren en de prijs die je moet betalen is het waard, dat verzeker ik je.

Dat is alles mensen, laat het me weten als je fouten opmerkt in deze instructable en geniet van je gloednieuwe IR USB-ontvanger!