docs

[mirrors/Programs.git] / c / tv-b-gone / main.c

/*\r
TV-B-Gone\r
Firmware\r
for use with ATtiny85\r
Mitch Altman + Limor Fried\r
7-Oct-07\r
\r
Distributed under Creative Commons 2.5 -- Attib & Share Alike\r
*/\r
\r
#include <avr/io.h>             // this contains all the IO port definitions\r
#include <avr/interrupt.h>      // definitions for interrupts\r
#include <avr/sleep.h>          // definitions for power-down modes\r
#include <avr/pgmspace.h>       // definitions or keeping constants in program memory\r
#include <avr/wdt.h>\r
#include "main.h"\r
\r
#define LED PB2         //  visible LED\r
#define IRLED1 PB0      //  IR LED\r
#define IRLED2 PB1      //  IR LED\r
\r
/*\r
This project transmits a bunch of TV POWER codes, one right after the other, \r
with a pause in between each.  (To have a visible indication that it is \r
transmitting, it also pulses a visible LED once each time a POWER code is \r
transmitted.)  That is all TV-B-Gone does.  The tricky part of TV-B-Gone \r
was collecting all of the POWER codes, and getting rid of the duplicates and \r
near-duplicates (because if there is a duplicate, then one POWER code will \r
turn a TV off, and the duplicate will turn it on again (which we certainly \r
do not want).  I have compiled the top-40 most popular codes with the \r
duplicates eliminated, both for North America (which is the same as Asia, as \r
far as POWER codes are concerned -- even though much of Asia USES PAL video) \r
and for Europe (which works for Australia, New Zealand, the Middle East, and \r
other parts of the world that use PAL video).\r
\r
Before creating a TV-B-Gone Kit, I originally started this project by hacking \r
the MiniPOV kit.  This presents a limitation, based on the size of\r
the Atmel ATtiny2313 internal flash memory, which is 2KB.  With 2KB we can only \r
fit about 7 POWER codes into the firmware's database of POWER codes.  40 codes\r
requires 8KB of flash memory, which is why we chose the ATtiny85 for the \r
TV-B-Gone Kit.\r
\r
This version of the firmware has the most popular 40 POWER codes for North America.\r
*/\r
\r
\r
/*\r
This project is a good example of how to use the AVR chip timers.\r
*/\r
\r
\r
/*\r
The hardware for this project is very simple:\r
     ATtiny85 has 8 pins:\r
       pin 1   connects to programming circuitry\r
       pin 2   one pin of ceramic resonator\r
       pin 3   one pin of ceramic resonator\r
       pin 4   ground\r
       pin 5   PB0 - visible LED, and also connects to programming circuitry\r
       pin 6   OC1A - IR emitter, through a PN2222A driver (with 47 ohm base resistor), and also connects to programming circuitry\r
       pin 7   push-button switch, and also connects to serial port programming circuitry\r
       pin 8   +3v\r
    See the schematic for more details.\r
\r
    This firmware requires using an 8.0MHz ceramic resonator \r
       (since the internal oscillator may not be accurate enough).\r
\r
    IMPORTANT:  to use the ceramic resonator, you must perform the following:\r
                    make burn-fuse_cr\r
*/\r
\r
\r
/*\r
The C compiler creates code that will transfer all constants into RAM when the microcontroller\r
resets.  Since this firmware has a table (powerCodes) that is too large to transfer into RAM,\r
the C compiler needs to be told to keep it in program memory space.  This is accomplished by\r
the macro PROGMEM (this is used in the definition for powerCodes).  Since the\r
C compiler assumes that constants are in RAM, rather than in program memory, when accessing\r
powerCodes, we need to use the pgm_read_word() and pgm_read_byte macros, and we need\r
to use powerCodes as an address.  This is done with PGM_P, defined below.  \r
For example, when we start a new powerCode, we first point to it with the following statement:\r
    PGM_P thecode_p = pgm_read_word(powerCodes+i);\r
The next read from the powerCode is a byte that indicates the carrier frequency, read as follows:\r
    uint8_t freq = pgm_read_byte(thecode_p);\r
Subsequent reads from the powerCode are onTime/offTime pairs, which are words, read as follows:\r
    ontime = pgm_read_word(thecode_p+(offset_into_table);\r
    offtime = pgm_read_word(thecode_p+(offset_into_table);\r
*/\r
\r
#define NOP __asm__ __volatile__ ("nop")\r
// This function delays the specified number of 10 microseconds\r
#define DELAY_CNT 11\r
void delay_ten_us(uint16_t us) {\r
  uint8_t timer;\r
  while (us != 0) {\r
    for (timer=0; timer <= DELAY_CNT; timer++) {\r
      NOP;\r
      NOP;\r
    }\r
    NOP;\r
    us--;\r
  }\r
}\r
\r
\r
// This function quickly pulses the visible LED (connected to PB0, pin 5)\r
void quickflashLED( void ) {\r
  // pulse LED on for 30ms\r
\r
  PORTB &= ~_BV(LED);         // turn on visible LED at PB0 by pulling pin to ground\r
  delay_ten_us(3000);         // 30 millisec delay\r
  PORTB |= _BV(LED);          // turn off visible LED at PB0 by pulling pin to +3V\r
}\r
\r
\r
// This function quickly pulses the visible LED (connected to PB0, pin 5) 4 times\r
void quickflashLED4x( void ) {\r
  quickflashLED();\r
  delay_ten_us(15000);        // 150 millisec delay\r
  quickflashLED();\r
  delay_ten_us(15000);        // 150 millisec delay\r
  quickflashLED();\r
  delay_ten_us(15000);        // 150 millisec delay\r
  quickflashLED();\r
}\r
\r
\r
// This function transmits one Code Element of a POWER code to the IR emitter, \r
//   given offTime and onTime for the codeElement\r
//     If offTime = 0 that signifies the last Code Element of the POWER code\r
//     and the delay_ten_us function will have no delay for offTime \r
//     (but we'll delay for 250 milliseconds in the main function)\r
void xmitCodeElement(uint16_t ontime, uint16_t offtime ) {\r
  // start Timer1 outputting the carrier frequency to IR emitters on OC1A (PB1, pin 6) and OC0A (PB0, pin 5)\r
  TCNT0 = 0; // reset the timers so they are aligned\r
  TCNT1 = 0;\r
  TIFR = 0;  // clean out the timer flags\r
\r
  TCCR0A =_BV(COM0A0) | _BV(WGM01);          // set up timer 0\r
\r
  TCCR1 =_BV(COM1A0) | _BV(CS10) | _BV(CTC1);      // set up and turn on timer 1\r
  //TCCR1 = 0b10010001  // CTC1 = 1 to reset Timer1 to 0 when it reaches the value in OCR1C (i.e., on Compare Match)\r
                        // PWM1A = 0 to disable PWM mode\r
                        // COM1A1:0 = 01 to toggle OC1A on Compare Match\r
                        // CS13:10 = 0001 to start Timer1 with prescaler set to divide by 1 (i.e., no prescaler divide)\r
  TCCR0B = _BV(CS00);                              // turn on timer 0 exactly 1 instruction later\r
\r
  // keep transmitting carrier for onTime\r
  delay_ten_us(ontime);\r
\r
  \r
  // turn off output to IR emitters on 0C1A (PB1, pin 6) for offTime\r
  TCCR1 = 0;      // stop Timer 1\r
  TCCR0B = 0;     // stop Timer 0, exactly one instruction later\r
  TCCR0A = 0;\r
\r
  PORTB &= ~_BV(IRLED1) & ~_BV(IRLED2);           // turn off IR LED\r
\r
  delay_ten_us(offtime);\r
}\r
\r
\r
void gotosleep(void) {\r
  // Shut down everything and put the CPU to sleep\r
  // put CPU into Power Down Sleep Mode\r
\r
  TCCR1 = 0;                      // turn off frequency generator (should be off already)\r
  TCCR0B = 0;\r
  PORTB |= _BV(LED); // turn on the button pullup, turn off visible LED\r
  PORTB &= ~_BV(IRLED1) & ~_BV(IRLED2);           // turn off IR LED\r
  delay_ten_us(1000);             // wait 10 millisec second\r
\r
  wdt_disable();\r
\r
  MCUCR = _BV(SM1) |  _BV(SE);    // power down mode,  SE=1 (bit 5) -- enables Sleep Modes\r
  sleep_cpu(); \r
}\r
\r
//extern const struct powercode powerCodes[] PROGMEM;\r
extern const PGM_P *powerCodes[] PROGMEM;\r
\r
extern uint8_t num_codes;\r
\r
int main(void) {\r
  uint8_t i, j;\r
  uint16_t ontime, offtime;\r
\r
  TCCR1 = 0;                      // turn off frequency generator (should be off already)\r
  TCCR0B = 0;\r
\r
  i = MCUSR;  // find out why we reset\r
  MCUSR = 0;  // clear reset flags immediately\r
\r
  // turn on watchdog timer immediately, this protects against\r
  // a 'stuck' system by resetting it\r
  wdt_enable(WDTO_8S); // 1 second long timeout\r
\r
  // Set the inputs and ouputs\r
  PORTB &= ~_BV(IRLED1) & ~_BV(IRLED2);        // IR LED is off when pin is low\r
  DDRB = _BV(LED) | _BV(IRLED1) | _BV(IRLED2);    // set the visible and IR LED pins to outputs\r
  PORTB = _BV(LED);  //  visible LED is off when pin is high\r
\r
  // check the reset flags\r
  if ((i & _BV(PORF)) ||   // batteries were inserted\r
      (i & _BV(BORF))) {    // brownout reset\r
    gotosleep(); // we only want to do something when the reset button is pressed\r
  }\r
\r
  for (i=0; i<num_codes; i++) {   // for every POWER code in our collection\r
    wdt_reset();        // make sure we dont get 'stuck' in a code\r
\r
    quickflashLED(); // visible indication that a code is being output\r
    PGM_P thecode_p = pgm_read_word(powerCodes+i);     // point to next POWER code\r
\r
    uint8_t freq = pgm_read_byte(thecode_p);\r
    // set OCR for Timer1 and Timer0 to output this POWER code's carrier frequency\r
    OCR0A = OCR1C = freq; \r
    \r
    // transmit all codeElements for this POWER code (a codeElement is an onTime and an offTime)\r
    // transmitting onTime means pulsing the IR emitters at the carrier frequency for the length of time specified in onTime\r
    // transmitting offTime means no output from the IR emitters for the length of time specified in offTime\r
    j = 0;  // index into codeElements of this POWER code\r
    do {\r
      // read the onTime and offTime from the program memory\r
      ontime = pgm_read_word(thecode_p+(j*4)+1);\r
      offtime = pgm_read_word(thecode_p+(j*4)+3);\r
\r
      xmitCodeElement(ontime, offtime);  // transmit this codeElement (ontime and offtime)\r
      j++;\r
    } while ( offtime != 0 );  // offTime = 0 signifies last codeElement for a POWER code\r
\r
    PORTB &= ~_BV(IRLED1) & ~_BV(IRLED2);           // turn off IR LED\r
\r
    // delay 250 milliseconds before transmitting next POWER code\r
    delay_ten_us(25000);\r
  }\r
  \r
\r
  // flash the visible LED on PB0  4 times to indicate that we're done\r
  delay_ten_us(65500); // wait maxtime \r
  quickflashLED4x();\r
\r
  gotosleep();\r
}\r