-/* $Id: ircontrol.c,v 1.1 2010/06/26 19:08:18 simimeie Exp $
+/* $Id: ircontrol.c,v 1.6 2010/07/10 07:36:28 simimeie Exp $
* Functions for the infrared receiver
*
* The infrared receiver is connected to PB0 / PCINT0.
#include <avr/io.h>
#include <avr/interrupt.h>
#include "ircontrol.h"
+#include "timers.h"
#include "console.h"
+/* NOTE1: Note that the signal we get from the sensor is inverted. If we
+ * read a zero, it means there was infrared on, if we read a one, infrared
+ * is off.
+ * NOTE2: Only NEC is implemented here right now, because MY remote uses
+ * that protocol. However, there may be references to RC5 because I had
+ * already thought about that and just left them for possible future use. */
+
+/* For RC5, one bit length is 1778 us, when it toggles we see half
+ * of it, i.e. 889 us.
+ * that equals around 7100 cpu cycles at 8 MHz. */
+#define RC5HALFLENINCYCLES ((CPUFREQ * 889UL) / 1000000UL)
+
+/* Source for most of this was the following nice page with illustrations
+ * and all that: http://www.sbprojects.com/knowledge/ir/nec.htm
+ * For NEC, we start with a 9000 us pulse, then 4500 us silence.
+ * Then the bits follow:
+ * a 1 is a 560 us pulse followed by 1690 us of silence (=2250 us total).
+ * a 0 is a 560 us pulse followed by 560 us of silence (=1120 us total).
+ * These values equal the following cpu cycle counts:
+ * 9000 us = 72000 cc, 4500 us = 36000 cc, 560 us = 4480, 1690 us = 13520 cc
+ * When the key stays pressed, it is not resubmitted, but instead a special
+ * "repeat" code is sent. That is: 9000 us pulse, 2250 us silence, 560 us
+ * pulse.
+ */
+#define NECSTARTLEN1 ((CPUFREQ * 9UL) / 1000UL)
+#define NECSTARTLEN2 ((CPUFREQ * 45UL) / 10000UL)
+#define NECPULSELEN ((CPUFREQ * 56UL) / 100000UL)
+#define NECZEROLEN ((CPUFREQ * 112UL) / 100000UL)
+#define NECONELEN ((CPUFREQ * 225UL) / 100000UL)
+#define NECREPEATLEN ((CPUFREQ * 225UL) / 100000UL)
+
+/* the NEC code contains 4 bytes, sent with LSB first:
+ * 0+1 are either the "extended address" or "address and inverted address".
+ * 2 is the command code
+ * 3 is the inverted command code
+ */
+
+static struct timestamp last0irqts;
+static struct timestamp last1irqts;
+static uint8_t lastpin = 0xff;
+static uint8_t codebytes[4];
+static uint8_t curcodebit = 0xff;
+static uint8_t lastcommand = 0xff;
+static uint8_t repeatcommand = 0xff;
+static uint16_t repeatticks = 0;
+/* Repeat after this many ticks (70 = 0.5s) */
+#define REPEATAFTERTICKS 100
+
+/* some example codes
+root@moodlight# !NSB! 11111111 00001000 11011111 00100000 (r)
+root@moodlight# !NSB! 11111111 00001000 01011111 10100000 (g)
+root@moodlight# !NSB! 11111111 00001000 10011111 01100000 (b)
+root@moodlight# !NSB! 11111111 00001000 00011111 11100000 (w)
+*/
+
ISR(PCINT0_vect) {
- uint8_t v = PINB & _BV(PB0);
- if (v) {
- console_printpgm_P(PSTR("!1!"));
- } else {
- console_printpgm_P(PSTR("!0!"));
+ uint8_t v;
+ struct timestamp curirqts;
+ uint32_t ts1diff; /* distance from last 1 */
+ uint32_t ts0diff; /* distance from last 0 */
+
+ v = PINB & _BV(0);
+ if (v == lastpin) { /* No change visible - spurious interrupt */
+ return;
+ }
+ curirqts = gettimestamp_noirq();
+ ts1diff = ((uint32_t)curirqts.ticks << 16) + curirqts.partticks;
+ ts0diff = ts1diff;
+ ts1diff -= ((uint32_t)last1irqts.ticks << 16) + last1irqts.partticks;
+ ts0diff -= ((uint32_t)last0irqts.ticks << 16) + last0irqts.partticks;
+ if (v) { /* Infrared just went away! */
+ if ((ts1diff >= (( 8 * NECSTARTLEN1) / 10))
+ && (ts1diff <= ((12 * NECSTARTLEN1) / 10))) {
+ /* NEC start bit */
+ /* console_printpgm_P(PSTR("!NSB!")); */
+ curcodebit = 0xfe; /* Wait for second part of start sequence */
+ } else {
+ if (curcodebit <= 32) { /* We're in a decoding attempt, so */
+ /* Check pulse length */
+ if ((ts1diff < (( 8 * NECPULSELEN) / 10))
+ || (ts1diff > ((12 * NECPULSELEN) / 10))) {
+ /* WRONG */
+ curcodebit = 0xff;
+ }
+ }
+ if (curcodebit == 32) {
+ if (codebytes[2] != (codebytes[3] ^ 0xff)) {
+ console_printpgm_P(PSTR("!CRC!"));
+ } else {
+ /* Successful decode! */
+ lastcommand = codebytes[2];
+ repeatcommand = codebytes[2];
+ repeatticks = curirqts.ticks;
+ console_printpgm_P(PSTR(" DEC>"));
+ console_printhex8(codebytes[0]);
+ console_printhex8(codebytes[1]);
+ console_printhex8(codebytes[2]);
+ console_printhex8(codebytes[3]);
+ }
+ }
+ }
+ last0irqts = curirqts;
+ } else { /* Infrared went on */
+ if ((ts1diff >= (( 8 * NECZEROLEN) / 10))
+ && (ts1diff <= ((12 * NECZEROLEN) / 10))) {
+ /* console_printpgm_P(PSTR("0")); */
+ if (curcodebit < 32) {
+ curcodebit++;
+ }
+ } else if ((ts1diff >= (( 8 * NECONELEN) / 10))
+ && (ts1diff <= ((12 * NECONELEN) / 10))) {
+ /* console_printpgm_P(PSTR("1")); */
+ if (curcodebit < 32) {
+ codebytes[curcodebit >> 3] |= (1 << (curcodebit & 0x07));
+ curcodebit++;
+ } else {
+ curcodebit = 0xff;
+ }
+ } else if ((ts0diff >= (( 8 * NECSTARTLEN2) / 10))
+ && (ts0diff <= ((12 * NECSTARTLEN2) / 10))) {
+ if (curcodebit == 0xfe) { /* voila, correct start sequence */
+ curcodebit = 0;
+ codebytes[0] = codebytes[1] = codebytes[2] = codebytes[3] = 0;
+ }
+ } else if ((ts0diff >= (( 8 * NECREPEATLEN) / 10))
+ && (ts0diff <= ((12 * NECREPEATLEN) / 10))) {
+ if (curcodebit == 0xfe) {
+ console_printpgm_P(PSTR(".REP."));
+ if ((curirqts.ticks - repeatticks) > REPEATAFTERTICKS) {
+ if ((repeatcommand == 0x00) || (repeatcommand == 0x01)) {
+ /* Only the up/down arrows are allowed to be repeated */
+ lastcommand = repeatcommand;
+ }
+ }
+ }
+ }
+ last1irqts = curirqts;
+ }
+#if 0
+ console_printpgm_P(PSTR("!"));
+ console_printhex8(tsdiff >> 24);
+ console_printhex8(tsdiff >> 16);
+ console_printhex8(tsdiff >> 8);
+ console_printhex8(tsdiff >> 0);
+ console_printpgm_P(PSTR("!"));
+#endif
+#if 0
+ if (tsdiff > ((24 * HALFRC5LENINCYCLES) / 10)) {
+ /* Start of new transmission */
+ console_printpgm_P(PSTR("!1["));
+ console_printhex8(v);
+ lastbit = 1;
+ } else if (tsdiff > ((15 * HALFRC5LENINCYCLES) / 10)) {
+ /* Different bit than last time */
+ lastbit = !lastbit;
+ if (lastbit) {
+ console_printpgm_P(PSTR("1"));
+ } else {
+ console_printpgm_P(PSTR("0"));
+ }
+ } else if ((tsdiff < ((15 * HALFRC5LENINCYCLES) / 10))
+ && (tsdiff > (( 5 * HALFRC5LENINCYCLES) / 10))) {
+ /* Same bit as last time */
+ if (lastbit) {
+ console_printpgm_P(PSTR("1"));
+ } else {
+ console_printpgm_P(PSTR("0"));
+ }
}
+#endif
+ lastpin = v;
}
void ircontrol_init(void)
{
/* Activate pullup */
- PORTB |= _BV(PB0);
+ PORTB |= _BV(0);
/* enable PCINT0 */
PCICR |= _BV(PCIE0);
/* Enable pin change interrupt 0 (=PB0) in pcint0 */
PCMSK0 |= _BV(PCINT0);
}
+
+uint8_t ircontrol_getlastcommand(void)
+{
+ uint8_t res;
+ res = lastcommand;
+ lastcommand = 0xff;
+ return res;
+}