Remote control kontrolleras via Internet (6 / 6 steg)

Steg 6: Inbäddade Aquila åtgärder

Med allt detta genomföras, mottagna koden kan enkelt kopieras utgör den Serial Monitor och klistra in den som en ny matris i koden. Sedan till Aquila action funktioner för att kalla det (eller de) matrisen och har en ännu bättre genom Aquila platform (fördelen med detta är att du inte behöver köpa mer tryckknappar och att du kommer att kunna automatisera som jag kommer att nämna nu) fjärrkontroll.

Ser detta som ett "enkelt" program för Altair, Tänk dig konfigurera det så att i N tid av dagen din TV skulle slå på och börja spela in dina favoritprogram.

Nu lägger vi till några fler rader för att genomföra Aquila plattformen. Jag är även en matris med en massa siffror. här är de fjärrkontrollen som jag använde skickar till TV jag använde (som i själva verket jag ur direkt seriell bildskärmen). Du måste ändra dessa siffror för de bildskärmen seriell returnerar

Även om jag lämnade dem där så man kunde se en matrisstruktur.

Eftersom tidpunkten är mycket viktig, kommer inte vi att använda digitalRead

för det är mycket långsam jämfört med vad vi kommer att använda.

Kolla länken referens efter koden; tillbaka på läraren.
Denna (PIND) sak innebär att formuläret stift 0 till 7 kommer att läsa endast
#define IRpin_PIN PIND

#include < Wire.h >
#include < Mesh.h >
#include < AquilaProtocol.h >< /p >< p > #define MASK 2 //This tas som ett binärt tal (00000010)
#define Boton 33 //Built-in Altair knapp (det har inverterad logif! LÅG = pressad, hög = inte pressad)
#define Boton2 10 //Extern knapp, normal logik! HÖG = pressad, låg = inte pressad!
#define IR 9
Den längsta puls som kommer att läsa kommer att vara 65ms (när koden gäller, det ska bli en mikrosekunder funktion
Så kommer det inte att tas som 65000ms (som detta 65 sekunder); 65 ms är faktiskt en hel del i denna miljö.
#define MAXPULSE 65000

Nuestra resolución de tiempo, entre más grande es el valor mejor,
Vår tid upplösning, ju större värde desto bättre, för det är mer precist
men det tar längre tid att bearbeta det
Och vi vill att förlora den precision som vi vann inte använder digitalRead
#define RESOLUTION 20

El pulso que se recibirá será en pares, 100 pares sv éste ámbito es alltsedan
Mottagna pulsen blir parvis, 100 par är faktiskt mycket.
uint16_t pulser [100] [2]. Kom ihåg att ett "värde" bestå i både på- och från LED, så i matrisen lagras i par.
uint8_t currentpulse = 0; Det ska användas för att veta hur många par från ON och har OFF mottagits.
bool full = false;</p><p>uint16_t turnON [120][2]={{46264,1100},{540,1160},{480,1960},{540,1080},{520,1120},{520,1120},{520,1100},{540,1080},{560,1060},{1420,1040},{600,1800},{720,920},{20324,980},{640,980},{660,1780},{740,880},{760,860},{760,880},{760,880},{760,880},{760,860},{1600,900},{760,1700},{760,880},{20384,940},{700,920},{700,1740},{760,880},{760,860},{780,860},{760,880},{760,900},{720,900},{1600,880},{740,1740},{760,860}};
Detta är ett exempel på hur en kod för att vrida på en TV ser ut, det kan vara olika till din, så måste du ändra matrisen i nästa funktioner (också detta en) :) < /p >< p > uint16_t vUP [120] [2] = {0}.
uint16_t vDWN [120] [2] = {0}.
uint16_t cUP [120] [2] = {0}.
uint16_t cDWN [120] [2] = {0}.
uint16_t inp [120] [2] = {0}. < /p >< p > bool encender (uint8_t param, bool gotParam)
{
Avundsvärd (turnON);
Delay(500);
} < /p >< p > bool volumenUP (uint8_t param, bool gotParam)
{
Enviar(vUP);
Delay(500);
} < /p >< p > bool volumenDWN (uint8_t param, bool gotParam)
{
Enviar(vDWN);
Delay(500);
} < /p >< p > bool canalUP (uint8_t param, bool gotParam)
{
Enviar(cUP);
Delay(500);
} < /p >< p > bool canalDWN (uint8_t param, bool gotParam)
{
Enviar(cDWN);
Delay(500);
} < /p >< p > bool input (uint8_t param, bool gotParam)
{
Enviar(INP);
Delay(500);
}

void setup(void)
{
Serial.BEGIN(9600);

Mesh.BEGIN();
Aquila.BEGIN();
Aquila.setClass("mx.makerlab.test");
Aquila.setName("Control");

Aquila.addAction ("vända på", encender);
Aquila.addAction ("Volumen +", volumenUP);
Aquila.addAction ("Volumen-", volumenDWN);
Aquila.addAction ("Chanel +", canalUP);
Aquila.addAction ("Chanel-", canalDWN);
Aquila.addAction ("Input", indata);

Mesh.announce(hub);

Serial.BEGIN(9600);
pinMode (Boton, indata);
pinMode (Boton2, indata);
pinMode (Boton2, INPUT_PULLUP);
pinMode (IR, OUTPUT);
pinMode (15, OUTPUT);
pinMode (14, OUTPUT); < /p >< p > / / 7 6 5 4 3 2 1 0
TCCR2A - (COM2A1, COM2A0, COM2B1, COM2B0, reserverade, reserverad, WGM21, WGM20)
7 6 5 4 3 2 1 0
TCCR2B - [FOC2A, FOC2B, reserverade, reserverade, WGM22, CS22, CS21, CS20] < /p >< p > TCCR2A = _BV(COM2A0) | _BV(COM2B1) | _BV(WGM21) | _BV(WGM20); A "eller" är gäller alla av dem och det ser ut här -> TCCR2A = 0110 0011 (99)
TCCR2B = _BV(WGM22) | _BV(CS21); A "eller" är tillämplig och det ser ut här -> TCCR2B = 0000 1010 = 10
OCR2A = 25; Inre tiden blir till 25 (kluvna mellan frekvensen av micro controller (16MHz) gånger 2 (eftersom uppdelningen visar bara hälften av vågen, vi vill veta hur länge en komplett cykel.
TCCR2A ^ = _BV(COM2A1); Förbereder IR LED < /p >< p > Serial.println ("redo att avkoda IR!"); Efter det här meddelandet vet vi att det precis har avslutat den SETUP delen och statistik läser pulser.
} < /p >< p > void IRcarrier (unsigned int matrix)
{
om (matris! = 0)
{
TCCR2A ^ = _BV(COM2A1); Ändrar den 8' th bit. Tänds lysdioden.
delayMicroseconds(matrix); Väntar matrix-mikrosekunder med LED påslaget.
TCCR2A ^ = _BV(COM2A1); Släcks lampan.
}
} < /p >< p > annullera avundsvärd (uint16_t pulse[120][2])
{
digitalWrite (15, låg).
för (int jag = 0; jag < 120; i ++)
{
om (puls [i] [0] == 0) //If en matris slot är tom, lämnar slingan.
{
bryta;
}
delayMicroseconds(pulse[i][0]); Väntar n mikrosekunder wi IR ledde bort.
IRcarrier(pulse[i][1]); Träder den función skicka förseningen som tar på från IR
}
digitalWrite (15, hög).
} < /p >< p > //The enda denna función gör skriver ut allt fått efter pulsen är över.
void printpulses()
{
Serial.println ("\n\r\n\rReceived: \n\rOFF\t|\tON");
Serial.Print("{");
för (uint8_t jag = 0; jag < currentpulse; i ++)
{
Serial.Print("{");
Serial.Print (pulserar [i] [0], DEC); DEC <-En caso de que no esté sv decimales, esto lo såta en pasarlo en decimales.
Serial.Print(",");
Serial.Print (pulserar [i] [1], DEC);
Serial.Print("}");
}
Serial.Print("};\n");
hela = sant;
}

void loop(void)
{< /p >< p > Mesh.loop();
Aquila.loop(); < /p >< p > digitalWrite (15, hög). Inbyggda lysdioder, inverterad logik.
digitalWrite (14, hög). Båda börjar off. < /p >< p > om (digitalRead(Boton2) == hög || (currentpulse! = 0))
{
om (digitalRead(Boton2) == hög)
{
Serial.println("Leyendo!");
digitalWrite (14, låg). GRÖN LYSDIOD!
hela = false;
}

uint16_t highpulse, lowpulse; Pulsen blir tillfälligt lagras på denna variabler.
highpulse = lowpulse = 0; Denna process kommer att splitter i steg, när lampan är vidare; HighPulse och när det är utanför; LowPulse.

Allt detta "medan" funktion är för när pulsen är hög (LED på)

---Komplex förklaring---/ /
Vi kommer att tillämpa vad är på stift 0-7 en "mask" och vi tar allt som är på ståndpunkten 00000100
Om vi beställer stiften detta sätt -> 76543210 vi en se på ett tydligare sätt som 00000100 på den tredje ståndpunkten, samma som (xxxxx2xx)
Operatorn "&" genererar en sanning bordlägger mellan 00000100 och vad är ansluten till stiften (micro controller kommer att ignorera vad är inte på pin 2, i princip).
Så, om det finns något ansluten till stift 2, det kommer att fungera.
medan (IRpin_PIN & (1 << MASK) & & full == false)
{
highpulse ++;
delayMicroseconds(RESOLUTION);

Om pulsen är att långa, scanning upphör.
Skriver ner allt fått och återställer räknarna.
om ((highpulse > = MAXPULSE) & & (currentpulse! = 0))
{
printpulses();
currentpulse = 0;
hemkomst.
}
}
om det aldrig fick den "om loop", och sedan lagras den nya hög pulsen i matrisen.
pulser [currentpulse] [0] = highpulse;

//---------------------------------------------

Processen upprepas för den andra delen av pulsen (kom ihåg att det består på en hög och en låg tillsammans)
Är samma som på de andra tag, endast med en annan notation, där _BV är BITVALUE. Kolla länkarna bistånd.
Och den här räknas varje gång mottagaren får ingenting.
tag (!. (IRpin_PIN & _BV(MASK)) & & full == false)
{
lowpulse ++;
delayMicroseconds(RESOLUTION);

Om pulsen är för lång, upphör skanning.
Skriver ner allt fått och återställer räknarna.
om ((lowpulse > = MAXPULSE) & & (currentpulse! = 0))
{
printpulses();
currentpulse = 0;
hemkomst.
}
}
pulser [currentpulse] [1] = lowpulse * upplösning;
En ON-OFF puls har lästs
hela processen upprepas tills några kommando överskrider längden på en på eller en (och kommer in till den "om loop").
currentpulse ++;
} < /p >< p > om (digitalRead(Boton) == låg & & full == true)
{
Enviar(Pulses);
Delay(500);
}
digitalWrite(14,HIGH);
} < /p >