Stap 7: IR afstandsbedieningen
Dus begonnen ben ik na ladayada IR tutorial:
http://www.ladyada.net/Learn/sensors/IR.html
Het was een werkelijk snelle manier om in IR en ik ben dankbaar variëren, maar het werd ontworpen met een ruime arduino in gedachten en ik werkte met een ATtiny2313 die niet hebben overal in de buurt van voldoende RAM om de klus te klaren.
Met behulp van haar schets met een kleine afstandsbediening die ik had liggen ik opgenomen van de power-knop en kreeg dit:
int PowerSignal [] [2] = {}
ON, OFF (in 10 van microseconden)
{1138, 574},
{66, 76},
{66, 78},
{68, 70},
{70, 76},
{66, 76},
{68, 74},
{68, 78},
{68, 210},
{72, 216},
{68, 214},
{70, 216},
{78, 206},
{70, 214},
{70, 216},
{70, 216},
{68, 72},
{74, 72},
{68, 216},
{68, 76},
{66, 78},
{70, 214},
{68, 78},
{66, 72},
{70, 74},
{68, 216},
{74, 70},
{68, 214},
{72, 216},
{72, 68},
{74, 214},
{66, 216},
{70, 214},
{72, 5014},
{1134, 292},
{62, 5532},
{1142, 294},
{58, 0}};
38 aan/uit paren, sommigen van hen te groot is voor één byte, zodat als ik moest doen als dit 152 bytes Ibehoefte zou.
Ik had genoeg flitser, maar het zou een goede hoeveelheid ruimte kon ik het sparen, maar als ik moest opnemen de binnenkomende signalen als dat ik mijn RAM-budget zouden blazen zonder zelfs maar overweegt de andere dingen die ik nodig RAM voor.
Ik kon de code heb gecontroleerd als het kwam in, maar timing dan een beetje moeilijk krijgt.
Ik dacht het voor een tijdje en ik een patroon in mijn IR-code merkte.
De signalen waren ofwel minder dan 1 MS of ze waren groter.
Met behulp van ladyada de code, had het een tolerantie van 20%, wat zou betekenen dat een van de lage aantallen zou met elkaar overeenkomen.
Was er in wezen geen verschil tussen een 680 en 780 microseconden, met de tolerantie.
Het was een soortgelijk geval voor de grotere dan 1ms, er waarden zijn een paar uitzonderingen, maar de meeste passen de regel.
Ik dacht bij mezelf, wat als ik behandel ze als één bits, een 0 voor minder dan 1 MS en een 1 als het ware groter.
Verpakt in als dat kwam ik met dit:
11000000 = 0xC0
00000000 = 0x00
01010101 = 0x55
01010101 = 0x55
00000100 = 0x04
00010000 = 0x10
00010001 = 0x11
01000101 = 0x45
01011101 = 0x5D
1100
Na het negeren van de laatste nibble (de helft van een byte) ik was in staat om op te slaan van het inkomend signaal ineens in slechts 9 bytes, en het signaal vergelijken zou alleen duren 9 zo goed!
Als ik meer functies wilde niet zou ik worden uitgevoerd uit flash voor het opslaan van codes en wordt zo klein, dat ze kunnen gemakkelijk zijn opgeslagen in EEPROM als ik moest.
Een bijkomend voordeel was dat controleren als de code die gematched geen meer dan 9 eenvoudige byte vergelijkingen was.
Neem een kijkje op de bijgevoegde code.
At de top die er een aantal zijn definieert de code gemakkelijker te volgen en te onderhouden.
Na dat is het patroon hierboven vermeld, opgeslagen als een matrix char en ingevoerd in de hexadecimale notatie.
Alles is eigenlijk in de listenForIR-functie, die voortdurend wordt aangeroepen vanuit de hoofdlus.
Opmerking, dit is gewoon simpel manifestatiecode, in een laatste project wil je een interrupt gebruikt om wakker wanneer de IR iets detecteert.
Ik heb een versie van code die dat doet.
Dus, hoe werkt listenForIR?
Laat het breken.
We beginnen met een while lus dat probeert om 9 bytes aan gegevens van de IR.
We beginnen met het instellen van de timer voor een 256 prescaler.
Bij 1MHz Laat dit ons tijd tot 65ms zonder overlopen.
IR ontvangers houden hun gegevens pin hoge standaard, lage gaan wanneer een gemoduleerde signaal wordt ontvangen.
Dus we wachten tot we een dieptepunt, en als we langer duren dan 56ms wachten wij opkopen.
Zodra we hebben een laag die we moeten tijd, maar we hoeven niet te tijd zo lang als voorheen, en we kunnen het gebruiken van een hoger niveau van nauwkeurigheid, zodat we de prescaler tot en met 8 wijzigen.
Als de laag wordt gehouden voor langer dan 1 MS, dan kunnen we springen, anders beëindigd de lus vroeg als de pin hoog gaat.
Het volgende stukje code heeft een mooi gebruik van bitsgewijze bewerkingen waarmee ons bijhouden van de wijzigingen snel en goedkoop (goedkoop in termen van cpu en geheugengebruik):
current_byte << = 1;
current_byte | = staat;
while(IR_LOW); in het geval van een weinig langer dan de bovenstaande timeout
We beginnen door alle beetjes links te verplaatsen.
We dan of in de waarde van 1 of 0, die haar waarde toevoegt aan de LSB (minst significante Bit).
We dan wacht, incase het was een lange lage dat wij op eerder overgeslagen.
Dan doen wij hetzelfde voor het hoge deel van de code.
Als we eenmaal alle 8 bits (4 paar lage & hoge), wij bewaren en opnieuw te beginnen.
Ervan uitgaande dat we krijgen alle 9 bytes, we sluiten de lus en het gewoon vergelijken met onze code.
Als ze overeenkomen, schakelen we de LED.
