├── Pronto
    ├── Pronto.cpp
    ├── Pronto.h
    ├── README.md
    └── examples
    │   ├── ProntoCodesSentOverSerial
    │       └── ProntoCodesSentOverSerial.ino
    │   ├── SendHardcodedPronto
    │       └── SendHardcodedPronto.ino
    │   ├── SendProntoHexWithoutLibraryHard
    │       └── SendProntoHexWithoutLibraryHard.ino
    │   └── SendProntoHexWithoutLibrarySerial
    │       └── SendProntoHexWithoutLibrarySerial.ino
├── README.md
└── send_pronto_hex.ino


/Pronto/Pronto.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Pronto.cpp - Library for sending Pronto hex infrared codes.
  3 | */
  4 | 
  5 | #include "Arduino.h"
  6 | #include "Pronto.h"
  7 | 
  8 | #include <avr/interrupt.h>
  9 | #include <stdio.h>
 10 | #include <avr/pgmspace.h>
 11 | #include <stdint.h>
 12 | #include <avr/io.h>
 13 | 
 14 | #define IR_TIMER1_OVF_vect TIMER1_OVF_vect //Definition for ISR Timer1
 15 | #define IR_TCCRnA TCCR1A
 16 | #define IR_TCCRnB TCCR1B
 17 | // #define IR_PIN PINB
 18 | // #define IR_DDR DDRB
 19 | // #define IR_BV _BV(1)
 20 | #define IR_TCNTn TCNT1
 21 | #define IR_TIFRn TIFR1
 22 | #define IR_TIMSKn TIMSK1
 23 | #define IR_TOIEn TOIE1
 24 | #define IR_ICRn ICR1
 25 | #define IR_OCRn OCR1A
 26 | #define IR_COMn0 COM1A0
 27 | #define IR_COMn1 COM1A1
 28 | 
 29 | #define PRONTO_IR_SOURCE 0 // Pronto code byte 0
 30 | #define PRONTO_FREQ_CODE 1 // Pronto code byte 1
 31 | #define PRONTO_SEQUENCE1_LENGTH 2 // Pronto code byte 2
 32 | #define PRONTO_SEQUENCE2_LENGTH 3 // Pronto code byte 3
 33 | #define PRONTO_CODE_START 4 // Pronto code byte 4
 34 | 
 35 | 
 36 | static Pronto pronto(9); // has to be here for the ISR to work properly
 37 | 
 38 | static const uint16_t *ir_code = NULL;
 39 | static uint16_t ir_cycle_count = 0;
 40 | static uint32_t ir_total_cycle_count = 0;
 41 | static uint8_t ir_seq_index = 0;
 42 | static uint8_t ir_led_state = 0;
 43 | 
 44 | Pronto::Pronto(int pin){ pinMode(pin, OUTPUT); _pin = pin; }
 45 | 
 46 | void Pronto::ir_on() { IR_TCCRnA |= (1 << IR_COMn1) + (1 << IR_COMn0); ir_led_state = 1; }
 47 | 
 48 | void Pronto::ir_off() { IR_TCCRnA &= ((~(1 << IR_COMn1)) & (~(1 << IR_COMn0)) ); ir_led_state = 0; }
 49 | 
 50 | void Pronto::ir_toggle() { if (ir_led_state) { ir_off(); } else { ir_on(); } }
 51 | 
 52 | void Pronto::ir_start(uint16_t *code) {
 53 | 	ir_code = code;
 54 | 	//  IR_PORT &= ~IR_BV; // Turn output off (atmega328 only)
 55 | 	//  IR_DDR |= IR_BV; // Set it as output (atmega328 only)
 56 | 	digitalWrite(_pin, LOW); // Turn output off
 57 | 	pinMode(_pin, OUTPUT); // Set it as output
 58 | 	IR_TCCRnA = 0x00; // Reset the pwm
 59 | 	IR_TCCRnB = 0x00;
 60 | 	uint16_t top = ( (F_CPU / 1000000.0) * code[PRONTO_FREQ_CODE] * 0.241246 ) - 1;
 61 | 	IR_ICRn = top;
 62 | 	IR_OCRn = top >> 1;
 63 | 	IR_TCCRnA = (1 << WGM11);
 64 | 	IR_TCCRnB = (1 << WGM13) | (1 << WGM12);
 65 | 	IR_TCNTn = 0x0000;
 66 | 	IR_TIFRn = 0x00;
 67 | 	IR_TIMSKn = 1 << IR_TOIEn;
 68 | 	ir_seq_index = PRONTO_CODE_START;
 69 | 	ir_cycle_count = 0;
 70 | 	ir_on();
 71 | 	IR_TCCRnB |= (1 << CS10);
 72 | }
 73 | 
 74 | #define TOTAL_CYCLES 40000 
 75 | // Turns off after this number of cycles. About 1 second
 76 | // FIXME: Turn off after having sent <---- Should be able to do this one easily now. since it doesn't have to be done inside of ISR
 77 | 
 78 | #if defined(IR_TIMER1_OVF_vect) //makes sure definition is in place
 79 | ISR(IR_TIMER1_OVF_vect) { pronto.handleInterrupt(); }  //here is the cooky part 
 80 | #endif
 81 | 
 82 | //and this is what was inside of ISR before. so you can see how the call is made through a var to launch the function.
 83 | //and the var is the Pronto pronto(9) you also have to class define this bad larry. in Pronto.h under Public. 
 84 | //because ISR acts like a global var. and all of the Variables inside of the class function have to be static. 
 85 | //or should be to make sure this thing is going to communicate propery.
 86 | void Pronto::handleInterrupt(){ 
 87 | 	uint16_t sequenceIndexEnd;
 88 | 	uint16_t repeatSequenceIndexStart;
 89 | 	ir_total_cycle_count++;
 90 | 	ir_cycle_count++;
 91 | 	if (ir_cycle_count == ir_code[ir_seq_index]) {
 92 | 		ir_toggle();
 93 | 		ir_cycle_count = 0;
 94 | 		ir_seq_index++;
 95 | 		sequenceIndexEnd = PRONTO_CODE_START + (ir_code[PRONTO_SEQUENCE1_LENGTH] << 1) + (ir_code[PRONTO_SEQUENCE2_LENGTH] << 1);
 96 | 		repeatSequenceIndexStart = PRONTO_CODE_START + (ir_code[PRONTO_SEQUENCE1_LENGTH] << 1);
 97 | 		if (ir_seq_index >= sequenceIndexEnd ) {
 98 | 			ir_seq_index = repeatSequenceIndexStart;
 99 | 			if (ir_total_cycle_count > TOTAL_CYCLES) {
100 | 				ir_off();
101 | 				TCCR1B &= ~(1<<CS10);
102 | 			}
103 | 		}
104 | 	}
105 | }
106 | 
107 | void Pronto::ir_stop() { IR_TCCRnA = 0x00; IR_TCCRnB = 0x00; } //Reset the PWM pin


--------------------------------------------------------------------------------
/Pronto/Pronto.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |   Pronto.h - Library for sending Pronto hex infrared codes.
 3 | */
 4 | 
 5 | #ifndef Pronto_h
 6 | #define Pronto_h
 7 | 
 8 | #include "Arduino.h"
 9 | 
10 | class Pronto {
11 | 	public:
12 | 		Pronto(int pin);
13 | 		void ir_start(uint16_t *code);
14 | 		void handleInterrupt(); //Interrupt Timer Overflow Function
15 | 	private:
16 | 		int _pin;
17 | 		void ir_on();
18 | 		void ir_off();
19 | 		void ir_toggle();
20 | 		void ir_stop();
21 | };
22 | 
23 | #endif


--------------------------------------------------------------------------------
/Pronto/README.md:
--------------------------------------------------------------------------------
  1 | Arduino Pronto Hex Sender
  2 | =========================
  3 | 
  4 | Code Contributors:
  5 | @stephenong stephenong / Arduino-IR-Remote-Control-Player
  6 | @garthoff garthoff / Arduino-IR-Remote-Control-Player
  7 | @probonopd probonopd / arduino-infrared-pronto
  8 | @eburud eburud / arduino-infrared-pronto
  9 | @kdschlosser kdschlosser / arduino-infrared-pronto
 10 | @tungusk tungusk / arduino-infrared-pronto
 11 | @jerkey jerkey / arduino-infrared-pronto
 12 | @ravivarmapm ravivarmapm / Arduino-IR-Remote-Control-Player
 13 |   
 14 | TY Every one for making this thing work. I couldn't find an easy solution for Samsung 42bit until now. 
 15 | and not having a HEAP of code is also a plus++
 16 | 
 17 | I only have an Adruino Uno and a Mega2560 for testing. It does work on the Uno and not on the Mega2560
 18 | and seeing that the UNO shares all the same Interrupt timer information with these chips. it should work with these as well
 19 | For Arduino Uno, Nano, Micro Magician, Mini Driver, Lilly Pad and any other board using ATmega 8, 168 or 328**
 20 | Only on Pins D9 or D10
 21 | To change the pins there are 2 locations. for the Library Version
 22 | 
 23 | Pronto.cpp static Pronto pronto(9);  //change the 9 to a 10
 24 | .ino file Pronto pronto(9);          //change the 9 to a 10
 25 |  
 26 |  
 27 | Excuse the crudeness of my code. I have only been at this 2 weeks. Still Learning
 28 | any suggestions and or code replacement and fixes are appreciated.
 29 | 
 30 | 
 31 | Arduino sketch to send Pronto Hex commands with an infrared LED attached to pin D9.
 32 | 
 33 | To send Sony12, device = 1, obc = 47, send the following command over the serial line withg 115200 N 1:
 34 | 
 35 | SEND 0000 0067 0000 000d 0060 0018 0030 0018 0030 0018 0030 0018 0030 0018 0018 0018 0030 0018 0018 0018 0030 0018 0018 0018 
 36 | 
 37 | There are examples with and without the use of the library. As well as over serial or hard coded into the ino file.
 38 | 
 39 | I bumped the serial speed up because some of these codes are long.
 40 | 
 41 | Based on IR_Player_ProntoCode.c by Stephen Ong
 42 | https://github.com/stephenong/Arduino-IR-Remote-Control-Player
 43 | 
 44 | This work is licenced under the Creative Commons Attribution-NonCommercial 
 45 | 3.0 Unported License. To view a copy of this licence, visit 
 46 | http://creativecommons.org/licenses/by-nc/3.0/ or send a letter to Creative 
 47 | Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.
 48 | 
 49 | http://creativecommons.org/licenses/by-nc/3.0/
 50 | 
 51 | 
 52 | 
 53 | // For Arduino Uno, Nano, Micro Magician, Mini Driver, Lilly Pad and any other board using ATmega 8, 168 or 328**
 54 | //TCCR1B = TCCR1B & B11111000 | B00000011;    // set timer 1 divisor to    64 for PWM frequency of   490.20 Hz (The DEFAULT)
 55 | //Only Timer 1 for Pins D9 and D10 on above specified chips
 56 | 
 57 | //For Arduino Mega1280, Mega2560, MegaADK, Spider or any other board using ATmega1280 or ATmega2560**
 58 | //TCCR1B = TCCR1B & B11111000 | B00000011;    // set timer 1 divisor to    64 for PWM frequency of   490.20 Hz
 59 | //To use the same timer without having to make modifications to the script You have to use Pind D11 and D12 on 
 60 | //      the above specified chips
 61 | 
 62 | //At the bottom is a complete list of all chips times and pins.
 63 | 
 64 | // For Arduino Uno, Nano, Micro Magician, Mini Driver, Lilly Pad and any other board using ATmega 8, 168 or 328**
 65 |  
 66 | //---------------------------------------------- Set PWM frequency for D5 & D6 -------------------------------
 67 |  
 68 | //TCCR0B = TCCR0B & B11111000 | B00000001;    // set timer 0 divisor to     1 for PWM frequency of 62500.00 Hz
 69 | //TCCR0B = TCCR0B & B11111000 | B00000010;    // set timer 0 divisor to     8 for PWM frequency of  7812.50 Hz
 70 | //TCCR0B = TCCR0B & B11111000 | B00000011;    // set timer 0 divisor to    64 for PWM frequency of   976.56 Hz (The DEFAULT)
 71 | //TCCR0B = TCCR0B & B11111000 | B00000100;    // set timer 0 divisor to   256 for PWM frequency of   244.14 Hz
 72 | //TCCR0B = TCCR0B & B11111000 | B00000101;    // set timer 0 divisor to  1024 for PWM frequency of    61.04 Hz
 73 |  
 74 |  
 75 | //---------------------------------------------- Set PWM frequency for D9 & D10 ------------------------------
 76 |  
 77 | //TCCR1B = TCCR1B & B11111000 | B00000001;    // set timer 1 divisor to     1 for PWM frequency of 31372.55 Hz
 78 | //TCCR1B = TCCR1B & B11111000 | B00000010;    // set timer 1 divisor to     8 for PWM frequency of  3921.16 Hz
 79 | //TCCR1B = TCCR1B & B11111000 | B00000011;    // set timer 1 divisor to    64 for PWM frequency of   490.20 Hz (The DEFAULT)
 80 | //TCCR1B = TCCR1B & B11111000 | B00000100;    // set timer 1 divisor to   256 for PWM frequency of   122.55 Hz
 81 | //TCCR1B = TCCR1B & B11111000 | B00000101;    // set timer 1 divisor to  1024 for PWM frequency of    30.64 Hz
 82 |  
 83 | //---------------------------------------------- Set PWM frequency for D3 & D11 ------------------------------
 84 |  
 85 | //TCCR2B = TCCR2B & B11111000 | B00000001;    // set timer 2 divisor to     1 for PWM frequency of 31372.55 Hz
 86 | //TCCR2B = TCCR2B & B11111000 | B00000010;    // set timer 2 divisor to     8 for PWM frequency of  3921.16 Hz
 87 | //TCCR2B = TCCR2B & B11111000 | B00000011;    // set timer 2 divisor to    32 for PWM frequency of   980.39 Hz
 88 | //TCCR2B = TCCR2B & B11111000 | B00000100;    // set timer 2 divisor to    64 for PWM frequency of   490.20 Hz (The DEFAULT)
 89 | //TCCR2B = TCCR2B & B11111000 | B00000101;    // set timer 2 divisor to   128 for PWM frequency of   245.10 Hz
 90 | //TCCR2B = TCCR2B & B11111000 | B00000110;    // set timer 2 divisor to   256 for PWM frequency of   122.55 Hz
 91 | //TCCR2B = TCCR2B & B11111000 | B00000111;    // set timer 2 divisor to  1024 for PWM frequency of    30.64 Hz
 92 |  
 93 |  
 94 |  
 95 | //For Arduino Mega1280, Mega2560, MegaADK, Spider or any other board using ATmega1280 or ATmega2560**
 96 |  
 97 | //---------------------------------------------- Set PWM frequency for D4 & D13 ------------------------------
 98 |  
 99 | //TCCR0B = TCCR0B & B11111000 | B00000001;    // set timer 0 divisor to     1 for PWM frequency of 62500.00 Hz
100 | //TCCR0B = TCCR0B & B11111000 | B00000010;    // set timer 0 divisor to     8 for PWM frequency of  7812.50 Hz
101 | //TCCR0B = TCCR0B & B11111000 | B00000011;    <// set timer 0 divisor to    64 for PWM frequency of   976.56 Hz (Default)
102 | //TCCR0B = TCCR0B & B11111000 | B00000100;    // set timer 0 divisor to   256 for PWM frequency of   244.14 Hz
103 | //TCCR0B = TCCR0B & B11111000 | B00000101;    // set timer 0 divisor to  1024 for PWM frequency of    61.04 Hz
104 |  
105 |  
106 | //---------------------------------------------- Set PWM frequency for D11 & D12 -----------------------------
107 |  
108 | //TCCR1B = TCCR1B & B11111000 | B00000001;    // set timer 1 divisor to     1 for PWM frequency of 31372.55 Hz
109 | //TCCR1B = TCCR1B & B11111000 | B00000010;    // set timer 1 divisor to     8 for PWM frequency of  3921.16 Hz
110 | //TCCR1B = TCCR1B & B11111000 | B00000011;    // set timer 1 divisor to    64 for PWM frequency of   490.20 Hz
111 | //TCCR1B = TCCR1B & B11111000 | B00000100;    // set timer 1 divisor to   256 for PWM frequency of   122.55 Hz
112 | //TCCR1B = TCCR1B & B11111000 | B00000101;    // set timer 1 divisor to  1024 for PWM frequency of    30.64 Hz
113 |  
114 | //---------------------------------------------- Set PWM frequency for D9 & D10 ------------------------------
115 |  
116 | //TCCR2B = TCCR2B & B11111000 | B00000001;    // set timer 2 divisor to     1 for PWM frequency of 31372.55 Hz
117 | //TCCR2B = TCCR2B & B11111000 | B00000010;    // set timer 2 divisor to     8 for PWM frequency of  3921.16 Hz
118 | //TCCR2B = TCCR2B & B11111000 | B00000011;    // set timer 2 divisor to    32 for PWM frequency of   980.39 Hz
119 | //TCCR2B = TCCR2B & B11111000 | B00000100;    // set timer 2 divisor to    64 for PWM frequency of   490.20 Hz
120 | //TCCR2B = TCCR2B & B11111000 | B00000101;    // set timer 2 divisor to   128 for PWM frequency of   245.10 Hz
121 | //TCCR2B = TCCR2B & B11111000 | B00000110;    // set timer 2 divisor to   256 for PWM frequency of   122.55 Hz
122 | //TCCR2B = TCCR2B & B11111000 | B00000111;    // set timer 2 divisor to  1024 for PWM frequency of    30.64 Hz
123 |  
124 |  
125 | //---------------------------------------------- Set PWM frequency for D2, D3 & D5 ---------------------------
126 |  
127 | //TCCR3B = TCCR3B & B11111000 | B00000001;    // set timer 3 divisor to     1 for PWM frequency of 31372.55 Hz
128 | //TCCR3B = TCCR3B & B11111000 | B00000010;    // set timer 3 divisor to     8 for PWM frequency of  3921.16 Hz
129 | //TCCR3B = TCCR3B & B11111000 | B00000011;    // set timer 3 divisor to    64 for PWM frequency of   490.20 Hz
130 | //TCCR3B = TCCR3B & B11111000 | B00000100;    // set timer 3 divisor to   256 for PWM frequency of   122.55 Hz
131 | //TCCR3B = TCCR3B & B11111000 | B00000101;    // set timer 3 divisor to  1024 for PWM frequency of    30.64 Hz
132 |  
133 |  
134 | //---------------------------------------------- Set PWM frequency for D6, D7 & D8 ---------------------------
135 |  
136 | //TCCR4B = TCCR4B & B11111000 | B00000001;    // set timer 4 divisor to     1 for PWM frequency of 31372.55 Hz
137 | //TCCR4B = TCCR4B & B11111000 | B00000010;    // set timer 4 divisor to     8 for PWM frequency of  3921.16 Hz
138 | //TCCR4B = TCCR4B & B11111000 | B00000011;    // set timer 4 divisor to    64 for PWM frequency of   490.20 Hz
139 | //TCCR4B = TCCR4B & B11111000 | B00000100;    // set timer 4 divisor to   256 for PWM frequency of   122.55 Hz
140 | //TCCR4B = TCCR4B & B11111000 | B00000101;    // set timer 4 divisor to  1024 for PWM frequency of    30.64 Hz
141 |  
142 |  
143 | //---------------------------------------------- Set PWM frequency for D44, D45 & D46 ------------------------
144 |  
145 | //TCCR5B = TCCR5B & B11111000 | B00000001;    // set timer 5 divisor to     1 for PWM frequency of 31372.55 Hz
146 | //TCCR5B = TCCR5B & B11111000 | B00000010;    // set timer 5 divisor to     8 for PWM frequency of  3921.16 Hz
147 | //TCCR5B = TCCR5B & B11111000 | B00000011;    // set timer 5 divisor to    64 for PWM frequency of   490.20 Hz
148 | //TCCR5B = TCCR5B & B11111000 | B00000100;    // set timer 5 divisor to   256 for PWM frequency of   122.55 Hz
149 | //TCCR5B = TCCR5B & B11111000 | B00000101;    // set timer 5 divisor to  1024 for PWM frequency of    30.64 Hz
150 |  
151 |  
152 | 
153 | 
154 | 


--------------------------------------------------------------------------------
/Pronto/examples/ProntoCodesSentOverSerial/ProntoCodesSentOverSerial.ino:
--------------------------------------------------------------------------------
 1 | /*
 2 | Send Pronto Hex via an IR LED connected to Arduino Pin D9.
 3 | Make sure you do not send a blank (" ") as the last character.
 4 | Send the following command over the serial line:
 5 |  
 6 | Sony12, device = 1, obc = 47
 7 | SEND 0000 0067 0000 000d 0060 0018 0030 0018 0030 0018 0030 0018 0030 0018 0018 0018 0030 0018 0018 0018 0030 0018 0018 0018 0018 0018 0018 0018 0018 03de
 8 |  
 9 | or
10 |  
11 | # RC5, device = 11, obc = 64
12 | SEND 0000 0073 0000 000B 0040 0020 0020 0020 0020 0040 0040 0040 0020 0020 0040 0020 0020 0020 0020 0020 0020 0020 0020 0020 0020 0CC8
13 |  
14 | Based on IR_Player_ProntoCode.c by Stephen Ong
15 | https://github.com/stephenong/Arduino-IR-Remote-Control-Player
16 | This work is licenced under the Creative Commons Attribution-NonCommercial 
17 | 3.0 Unported License. To view a copy of this licence, visit 
18 | http://creativecommons.org/licenses/by-nc/3.0/ or send a letter to Creative 
19 | Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.
20 | http://creativecommons.org/licenses/by-nc/3.0/
21 | */
22 | 
23 | #include <Pronto.h>
24 | 
25 | 
26 | 
27 | Pronto pronto(9);
28 | 
29 | const uint16_t inputLength = 512;
30 | 
31 | void setup() {
32 | 	Serial.begin(9600);
33 | 	while (Serial.available());
34 | 	Serial.print("Hello World!\r\n enter \"SEND\" and the Pronto Code.\r\n");
35 | 	Serial.print("0000 spaces between the Pronto Hex\r\n");
36 | 	Serial.print("no commas and no trailing spaces\r\n");
37 | 	Serial.print("This is a working Hex so you can copy and paste it.\r\n");
38 | 	//This is one of thoes very ugly Samsung Smart tv power codes. I think it is 42 bit at 37.9khz
39 | 	//this is one very long array 78 total cells my sggestion would be to run it through serial
40 | 	//or script in loading the Pronto Codes from a file. This would just chew up to much memory. there are almost 200
41 | 	//Pronto Codes like this for a Samsung TV My use if for power on only. all the rest of the commands are wifi or even the EXLINK Port
42 | 	//that is rs-232
43 | 	// Not working yet Serial.println("Example: SEND 0x0 0x6D 0x22 0x3 0xA9 0xA8 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x3F 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x40 0x15 0x15 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x702 0xA9 0xA8 0x15 0x15 0x15 0xE6E");
44 | 	Serial.println("Example: SEND 0000 006d 0022 0003 00a9 00a8 0015 003f 0015 003f 0015 003f 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 003f 0015 003f 0015 003f 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 003f 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0040 0015 0015 0015 003f 0015 003f 0015 003f 0015 003f 0015 003f 0015 003f 0015 0702 00a9 00a8 0015 0015 0015 0e6e");
45 | }
46 | 
47 | void loop() {
48 | 	if ( Serial.available() > 0 ) {
49 | 		static char input[inputLength];
50 | 		static uint16_t i;
51 | 		char c = Serial.read();
52 | 		if ( c != '\r' && c != '\n' && i < inputLength-1)
53 | 			input[i++] = c;
54 | 		else {
55 | 			input[i] = '\0';
56 | 			i = 0;
57 | 			uint16_t array[80];
58 | 			uint16_t j = 0;
59 | 			if ( !strncmp(input, "SEND", 4) ) {
60 | 				char* p = input+4;
61 | 				while ( (p = strchr(p, ' ')) != NULL )
62 | 						array[j++] = strtol(p, &p, 16);
63 | 				pronto.ir_start(array);
64 | 				Serial.print("SENT ");
65 | 				for ( uint8_t i = 0; i < j; i++ ) {
66 | 					Serial.print ("0x");
67 | 					Serial.print (array[i], HEX);
68 | 					Serial.print(" ");
69 | 				}
70 | 				Serial.println();
71 | 			}
72 | 		}
73 | 	}
74 | }
75 | 


--------------------------------------------------------------------------------
/Pronto/examples/SendHardcodedPronto/SendHardcodedPronto.ino:
--------------------------------------------------------------------------------
 1 | /*
 2 | Send Pronto Hex via an IR LED connected to Arduino Pin D9.
 3 | 
 4 | Store Pronto Code in uint16_t in either 0x00 or 0000 format commas between each HEX
 5 |  
 6 | Based on IR_Player_ProntoCode.c by Stephen Ong
 7 | https://github.com/stephenong/Arduino-IR-Remote-Control-Player
 8 | This work is licenced under the Creative Commons Attribution-NonCommercial 
 9 | 3.0 Unported License. To view a copy of this licence, visit 
10 | http://creativecommons.org/licenses/by-nc/3.0/ or send a letter to Creative 
11 | Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.
12 | http://creativecommons.org/licenses/by-nc/3.0/
13 | */
14 | #include <Pronto.h>
15 | 
16 | 
17 | 
18 | Pronto pronto(9);
19 | 
20 | uint16_t up[78] = { 0x0, 0x6D, 0x22, 0x3, 0xA9, 0xA8, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x3F, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x40, 0x15, 0x15, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x702, 0xA9, 0xA8, 0x15, 0x15, 0x15, 0xE6E };
21 | 
22 | void setup() {
23 | 	Serial.begin(115200);
24 | 	while (Serial.available());
25 | 	Serial.print("Hello World!\r\n enter \"SEND\" to send IR\r\n");
26 | }
27 | 
28 | void loop() {
29 | 	if (Serial.available() > 0 ) {
30 | 		String inString = Serial.readString();
31 | 		if (inString.startsWith("SEND")) {
32 | 			int j = 78;
33 | 			pronto.ir_start(up);
34 | 			Serial.print("SENT: ");
35 | 			for ( int i = 0; i < j; i++ ) {
36 | 				Serial.print ("0x");
37 | 				Serial.print (up[i], HEX);
38 | 				Serial.print(" ");
39 | 			}
40 | 			Serial.print("\r\n");
41 | 		}
42 | 	}
43 | }
44 | 
45 | 
46 | 


--------------------------------------------------------------------------------
/Pronto/examples/SendProntoHexWithoutLibraryHard/SendProntoHexWithoutLibraryHard.ino:
--------------------------------------------------------------------------------
  1 | /*
  2 | Send Pronto Hex via an IR LED connected to Arduino Pin D9.
  3 | 
  4 | Store Pronto Code in uint16_t in either 0x00 or 0000 format commas between each HEX
  5 | 
  6 | Based on IR_Player_ProntoCode.c by Stephen Ong
  7 | https://github.com/stephenong/Arduino-IR-Remote-Control-Player
  8 | This work is licenced under the Creative Commons Attribution-NonCommercial 
  9 | 3.0 Unported License. To view a copy of this licence, visit 
 10 | http://creativecommons.org/licenses/by-nc/3.0/ or send a letter to Creative 
 11 | Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.
 12 | http://creativecommons.org/licenses/by-nc/3.0/
 13 | */
 14 | 
 15 | #include <avr/interrupt.h>
 16 | #include <stdio.h>
 17 | #include <avr/pgmspace.h>
 18 | #include <stdint.h>
 19 | #include <avr/io.h>
 20 | #define IR_PORT PORTB
 21 | // #define IR_PIN PINB
 22 | // #define IR_DDR DDRB
 23 | // #define IR_BV _BV(1)
 24 | #define IR_OCR OCR1A
 25 | #define IR_TCCRnA TCCR1A
 26 | #define IR_TCCRnB TCCR1B
 27 | #define IR_TCNTn TCNT1
 28 | #define IR_TIFRn TIFR1
 29 | #define IR_TIMSKn TIMSK1
 30 | #define IR_TOIEn TOIE1
 31 | #define IR_ICRn ICR1
 32 | #define IR_OCRn OCR1A
 33 | #define IR_COMn0 COM1A0
 34 | #define IR_COMn1 COM1A1
 35 | #define PRONTO_IR_SOURCE 0 // Pronto code byte 0
 36 | #define PRONTO_FREQ_CODE 1 // Pronto code byte 1
 37 | #define PRONTO_SEQUENCE1_LENGTH 2 // Pronto code byte 2
 38 | #define PRONTO_SEQUENCE2_LENGTH 3 // Pronto code byte 3
 39 | #define PRONTO_CODE_START 4 // Pronto code byte 4
 40 | 
 41 | int _pin = 9; //change number to change the pinMode
 42 | static const uint16_t *ir_code = NULL;
 43 | static uint16_t ir_cycle_count = 0;
 44 | static uint32_t ir_total_cycle_count = 0;
 45 | static uint8_t ir_seq_index = 0;
 46 | static uint8_t ir_led_state = 0;
 47 | 
 48 | void ir_on()
 49 | {
 50 |   IR_TCCRnA |= (1<<IR_COMn1) + (1<<IR_COMn0);
 51 |   ir_led_state = 1;
 52 | }
 53 | 
 54 | void ir_off()
 55 | {
 56 |   IR_TCCRnA &= ((~(1<<IR_COMn1)) & (~(1<<IR_COMn0)) );
 57 |   ir_led_state = 0;
 58 | }
 59 | 
 60 | void ir_toggle()
 61 | {
 62 |   if (ir_led_state)
 63 |     ir_off();
 64 |   else
 65 |     ir_on();
 66 | }
 67 | 
 68 | void ir_start(uint16_t *code)
 69 | {
 70 |   ir_code = code;
 71 | //  IR_PORT &= ~IR_BV; // Turn output off (atmega328 only)
 72 |   digitalWrite(_pin,LOW); // Turn output off
 73 | //  IR_DDR |= IR_BV; // Set it as output (atmega328 only)
 74 |   pinMode(_pin,OUTPUT); // Set it as output
 75 |   IR_TCCRnA = 0x00; // Reset the pwm
 76 |   IR_TCCRnB = 0x00;
 77 |   //printf_P(PSTR("FREQ CODE: %hd\r\n"), code[PRONTO_FREQ_CODE]);
 78 |   uint16_t top = ( (F_CPU/1000000.0) * code[PRONTO_FREQ_CODE] * 0.241246 ) - 1;
 79 |   //printf_P(PSTR("top: %hu\n\r"), top);
 80 |   IR_ICRn = top;
 81 |   IR_OCRn = top >> 1;
 82 |   IR_TCCRnA = (1<<WGM11);
 83 |   IR_TCCRnB = (1<<WGM13) | (1<<WGM12);
 84 |   IR_TCNTn = 0x0000;
 85 |   IR_TIFRn = 0x00;
 86 |   IR_TIMSKn = 1 << IR_TOIEn;
 87 |   ir_seq_index = PRONTO_CODE_START;
 88 |   ir_cycle_count = 0;
 89 |   ir_on();
 90 |   IR_TCCRnB |= (1<<CS10);
 91 | }
 92 | 
 93 | #define TOTAL_CYCLES 80000 // Turns off after this number of
 94 | // cycles. About 2 seconds
 95 | // FIXME: Turn off after having sent
 96 | ISR(TIMER1_OVF_vect) {
 97 |   uint16_t sequenceIndexEnd;
 98 |   uint16_t repeatSequenceIndexStart;
 99 |   ir_total_cycle_count++;
100 |   ir_cycle_count++;
101 | 
102 |   if (ir_cycle_count== ir_code[ir_seq_index]) {
103 |     ir_toggle();
104 |     ir_cycle_count = 0;
105 |     ir_seq_index++;
106 |     sequenceIndexEnd = PRONTO_CODE_START +
107 |       (ir_code[PRONTO_SEQUENCE1_LENGTH]<<1) +
108 |       (ir_code[PRONTO_SEQUENCE2_LENGTH]<<1);
109 | 
110 |     repeatSequenceIndexStart = PRONTO_CODE_START +
111 |       (ir_code[PRONTO_SEQUENCE1_LENGTH]<<1);
112 | 
113 |     if (ir_seq_index >= sequenceIndexEnd ) {
114 |       ir_seq_index = repeatSequenceIndexStart;
115 | 
116 |       if(ir_total_cycle_count>TOTAL_CYCLES) {
117 |         ir_off();
118 |         TCCR1B &= ~(1<<CS10);
119 |       }
120 |     }
121 |   }
122 | }
123 | 
124 | void ir_stop()
125 | {
126 |   IR_TCCRnA = 0x00; // Reset the pwm
127 |   IR_TCCRnB = 0x00;
128 | }
129 | 
130 | const uint16_t inputLength = 512;
131 | 
132 | // Codes can either be 0x00 or 0000 format
133 | uint16_t up[78] = { 0x0, 0x6D, 0x22, 0x3, 0xA9, 0xA8, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x3F, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x40, 0x15, 0x15, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x3F, 0x15, 0x702, 0xA9, 0xA8, 0x15, 0x15, 0x15, 0xE6E };
134 | 
135 | void setup() {
136 | 	Serial.begin(115200);
137 | 	while (Serial.available());
138 | 	Serial.print("Hello World!\r\n enter \"SEND\" to send IR\r\n");
139 | }
140 | 
141 | void loop() {
142 | 	if (Serial.available() > 0 ) {
143 | 		String inString = Serial.readString();
144 | 		if (inString.startsWith("SEND")) {
145 | 			int j = 78;
146 | 			ir_start(up);
147 | 			Serial.print("SENT: ");
148 | 			for ( int i = 0; i < j; i++ ) {
149 | 				Serial.print ("0x");
150 | 				Serial.print (up[i], HEX);
151 | 				Serial.print(" ");
152 | 			}
153 | 			Serial.print("\r\n");
154 | 		}
155 | 	}
156 | }


--------------------------------------------------------------------------------
/Pronto/examples/SendProntoHexWithoutLibrarySerial/SendProntoHexWithoutLibrarySerial.ino:
--------------------------------------------------------------------------------
  1 | /*
  2 | Send Pronto Hex via an IR LED connected to Arduino Pin D9.
  3 | Make sure you do not send a blank (" ") as the last character.
  4 | Send the following command over the serial line:
  5 |  
  6 | Sony12, device = 1, obc = 47
  7 | SEND 0000 0067 0000 000d 0060 0018 0030 0018 0030 0018 0030 0018 0030 0018 0018 0018 0030 0018 0018 0018 0030 0018 0018 0018 0018 0018 0018 0018 0018 03de
  8 |  
  9 | or
 10 |  
 11 | # RC5, device = 11, obc = 64
 12 | SEND 0000 0073 0000 000B 0040 0020 0020 0020 0020 0040 0040 0040 0020 0020 0040 0020 0020 0020 0020 0020 0020 0020 0020 0020 0020 0CC8
 13 |  
 14 | Based on IR_Player_ProntoCode.c by Stephen Ong
 15 | https://github.com/stephenong/Arduino-IR-Remote-Control-Player
 16 | This work is licenced under the Creative Commons Attribution-NonCommercial 
 17 | 3.0 Unported License. To view a copy of this licence, visit 
 18 | http://creativecommons.org/licenses/by-nc/3.0/ or send a letter to Creative 
 19 | Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.
 20 | http://creativecommons.org/licenses/by-nc/3.0/
 21 | */
 22 | 
 23 | #include <avr/interrupt.h>
 24 | #include <stdio.h>
 25 | #include <avr/pgmspace.h>
 26 | #include <stdint.h>
 27 | #include <avr/io.h>
 28 | #define IR_PORT PORTB
 29 | // #define IR_PIN PINB
 30 | // #define IR_DDR DDRB
 31 | // #define IR_BV _BV(1)
 32 | #define IR_OCR OCR1A
 33 | #define IR_TCCRnA TCCR1A
 34 | #define IR_TCCRnB TCCR1B
 35 | #define IR_TCNTn TCNT1
 36 | #define IR_TIFRn TIFR1
 37 | #define IR_TIMSKn TIMSK1
 38 | #define IR_TOIEn TOIE1
 39 | #define IR_ICRn ICR1
 40 | #define IR_OCRn OCR1A
 41 | #define IR_COMn0 COM1A0
 42 | #define IR_COMn1 COM1A1
 43 | #define PRONTO_IR_SOURCE 0 // Pronto code byte 0
 44 | #define PRONTO_FREQ_CODE 1 // Pronto code byte 1
 45 | #define PRONTO_SEQUENCE1_LENGTH 2 // Pronto code byte 2
 46 | #define PRONTO_SEQUENCE2_LENGTH 3 // Pronto code byte 3
 47 | #define PRONTO_CODE_START 4 // Pronto code byte 4
 48 | 
 49 | static const uint16_t *ir_code = NULL;
 50 | static uint16_t ir_cycle_count = 0;
 51 | static uint32_t ir_total_cycle_count = 0;
 52 | static uint8_t ir_seq_index = 0;
 53 | static uint8_t ir_led_state = 0;
 54 | 
 55 | void ir_on()
 56 | {
 57 |   IR_TCCRnA |= (1<<IR_COMn1) + (1<<IR_COMn0);
 58 |   ir_led_state = 1;
 59 | }
 60 | 
 61 | void ir_off()
 62 | {
 63 |   IR_TCCRnA &= ((~(1<<IR_COMn1)) & (~(1<<IR_COMn0)) );
 64 |   ir_led_state = 0;
 65 | }
 66 | 
 67 | void ir_toggle()
 68 | {
 69 |   if (ir_led_state)
 70 |     ir_off();
 71 |   else
 72 |     ir_on();
 73 | }
 74 | 
 75 | void ir_start(uint16_t *code)
 76 | {
 77 |   ir_code = code;
 78 | //  IR_PORT &= ~IR_BV; // Turn output off (atmega328 only)
 79 |   digitalWrite(9,LOW); // Turn output off
 80 | //  IR_DDR |= IR_BV; // Set it as output (atmega328 only)
 81 |   pinMode(9,OUTPUT); // Set it as output
 82 |   IR_TCCRnA = 0x00; // Reset the pwm
 83 |   IR_TCCRnB = 0x00;
 84 |   //printf_P(PSTR("FREQ CODE: %hd\r\n"), code[PRONTO_FREQ_CODE]);
 85 |   uint16_t top = ( (F_CPU/1000000.0) * code[PRONTO_FREQ_CODE] * 0.241246 ) - 1;
 86 |   //printf_P(PSTR("top: %hu\n\r"), top);
 87 |   IR_ICRn = top;
 88 |   IR_OCRn = top >> 1;
 89 |   IR_TCCRnA = (1<<WGM11);
 90 |   IR_TCCRnB = (1<<WGM13) | (1<<WGM12);
 91 |   IR_TCNTn = 0x0000;
 92 |   IR_TIFRn = 0x00;
 93 |   IR_TIMSKn = 1 << IR_TOIEn;
 94 |   ir_seq_index = PRONTO_CODE_START;
 95 |   ir_cycle_count = 0;
 96 |   ir_on();
 97 |   IR_TCCRnB |= (1<<CS10);
 98 | }
 99 | 
100 | #define TOTAL_CYCLES 80000 // Turns off after this number of
101 | // cycles. About 2 seconds
102 | // FIXME: Turn off after having sent
103 | ISR(TIMER1_OVF_vect) {
104 |   uint16_t sequenceIndexEnd;
105 |   uint16_t repeatSequenceIndexStart;
106 |   ir_total_cycle_count++;
107 |   ir_cycle_count++;
108 | 
109 |   if (ir_cycle_count== ir_code[ir_seq_index]) {
110 |     ir_toggle();
111 |     ir_cycle_count = 0;
112 |     ir_seq_index++;
113 |     sequenceIndexEnd = PRONTO_CODE_START +
114 |       (ir_code[PRONTO_SEQUENCE1_LENGTH]<<1) +
115 |       (ir_code[PRONTO_SEQUENCE2_LENGTH]<<1);
116 | 
117 |     repeatSequenceIndexStart = PRONTO_CODE_START +
118 |       (ir_code[PRONTO_SEQUENCE1_LENGTH]<<1);
119 | 
120 |     if (ir_seq_index >= sequenceIndexEnd ) {
121 |       ir_seq_index = repeatSequenceIndexStart;
122 | 
123 |       if(ir_total_cycle_count>TOTAL_CYCLES) {
124 |         ir_off();
125 |         TCCR1B &= ~(1<<CS10);
126 |       }
127 |     }
128 |   }
129 | }
130 | 
131 | void ir_stop()
132 | {
133 |   IR_TCCRnA = 0x00; // Reset the pwm
134 |   IR_TCCRnB = 0x00;
135 | }
136 | 
137 | const uint16_t inputLength = 512;
138 | 
139 | void setup() {
140 | 	Serial.begin(9600);
141 | 	while (Serial.available());
142 | 	Serial.print("Hello World!\r\n enter \"SEND\" and the Pronto Code.\r\n");
143 | 	Serial.print("0000 spaces between the Pronto Hex\r\n");
144 | 	Serial.print("no commas and no trailing spaces\r\n");
145 | 	Serial.print("This is a working Hex so you can copy and paste it.\r\n");
146 | 	//This is one of thoes very ugly Samsung Smart tv power codes. I think it is 42 bit at 37.9khz
147 | 	//this is one very long array 78 total cells my sggestion would be to run it through serial
148 | 	//or script in loading the Pronto Codes from a file. This would just chew up to much memory. there are almost 200
149 | 	//Pronto Codes like this for a Samsung TV My use if for power on only. all the rest of the commands are wifi or even the EXLINK Port
150 | 	//that is rs-232
151 | 	// Not working yet Serial.println("Example: SEND 0x0 0x6D 0x22 0x3 0xA9 0xA8 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x3F 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x15 0x40 0x15 0x15 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x3F 0x15 0x702 0xA9 0xA8 0x15 0x15 0x15 0xE6E");
152 | 	Serial.println("Example: SEND 0000 006d 0022 0003 00a9 00a8 0015 003f 0015 003f 0015 003f 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 003f 0015 003f 0015 003f 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 003f 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0015 0040 0015 0015 0015 003f 0015 003f 0015 003f 0015 003f 0015 003f 0015 003f 0015 0702 00a9 00a8 0015 0015 0015 0e6e");
153 | }
154 | 
155 | void loop() {
156 | 	if ( Serial.available() > 0 ) {
157 | 		static char input[inputLength];
158 | 		static uint16_t i;
159 | 		char c = Serial.read();
160 | 		if ( c != '\r' && c != '\n' && i < inputLength-1)
161 | 			input[i++] = c;
162 | 		else {
163 | 			input[i] = '\0';
164 | 			i = 0;
165 | 			uint16_t array[80];
166 | 			uint16_t j = 0;
167 | 			if ( !strncmp(input, "SEND", 4) ) {
168 | 				char* p = input+4;
169 | 				while ( (p = strchr(p, ' ')) != NULL )
170 | 						array[j++] = strtol(p, &p, 16);
171 | 				ir_start(array);
172 | 				Serial.print("SENT ");
173 | 				for ( uint8_t i = 0; i < j; i++ ) {
174 | 					Serial.print ("0x");
175 | 					Serial.print (array[i], HEX);
176 | 					Serial.print(" ");
177 | 				}
178 | 				Serial.println();
179 | 			}
180 | 		}
181 | 	}
182 | }
183 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Arduino Pronto Hex Sender
 2 | =========================
 3 | 
 4 | Arduino sketch to send Pronto Hex commands with an infrared LED attached to pin D9.
 5 | 
 6 | To send Sony12, device = 1, obc = 47, send the following command over the serial line withg 9600 N 1:
 7 | <pre>
 8 | SEND 0000 0067 0000 000d 0060 0018 0030 0018 0030 0018 0030 0018 0030 0018 0018 0018 0030 0018 0018 0018 0030 0018 0018 0018 0018 0018 0018 0018 0018 03de
 9 | </pre>
10 | 
11 | You can find out these commands from community maintained databases such as http://irdb.tk
12 | 
13 | Make sure you send a newline character at the end of the line.
14 | 


--------------------------------------------------------------------------------
/send_pronto_hex.ino:
--------------------------------------------------------------------------------
  1 | /*
  2 | Send Pronto Hex via an IR LED connected to Arduino Pin D9.
  3 | Make sure you do not send a blank (" ") as the last character.
  4 | Send the following command over the serial line:
  5 |  
  6 | Sony12, device = 1, obc = 47
  7 | SEND 0000 0067 0000 000d 0060 0018 0030 0018 0030 0018 0030 0018 0030 0018 0018 0018 0030 0018 0018 0018 0030 0018 0018 0018 0018 0018 0018 0018 0018 03de
  8 |  
  9 | or
 10 |  
 11 | # RC5, device = 11, obc = 64
 12 | SEND 0000 0073 0000 000B 0040 0020 0020 0020 0020 0040 0040 0040 0020 0020 0040 0020 0020 0020 0020 0020 0020 0020 0020 0020 0020 0CC8
 13 |  
 14 | Based on IR_Player_ProntoCode.c by Stephen Ong
 15 | https://github.com/stephenong/Arduino-IR-Remote-Control-Player
 16 | 
 17 | This work is licenced under the Creative Commons Attribution-NonCommercial 
 18 | 3.0 Unported License. To view a copy of this licence, visit 
 19 | http://creativecommons.org/licenses/by-nc/3.0/ or send a letter to Creative 
 20 | Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.
 21 | 
 22 | http://creativecommons.org/licenses/by-nc/3.0/
 23 | */
 24 | 
 25 | #include <avr/interrupt.h>
 26 | #include <stdio.h>
 27 | #include <avr/pgmspace.h>
 28 | #include <stdint.h>
 29 | #include <avr/io.h>
 30 | #define IR_PORT PORTB
 31 | // #define IR_PIN PINB
 32 | // #define IR_DDR DDRB
 33 | // #define IR_BV _BV(1)
 34 | #define IR_OCR OCR1A
 35 | #define IR_TCCRnA TCCR1A
 36 | #define IR_TCCRnB TCCR1B
 37 | #define IR_TCNTn TCNT1
 38 | #define IR_TIFRn TIFR1
 39 | #define IR_TIMSKn TIMSK1
 40 | #define IR_TOIEn TOIE1
 41 | #define IR_ICRn ICR1
 42 | #define IR_OCRn OCR1A
 43 | #define IR_COMn0 COM1A0
 44 | #define IR_COMn1 COM1A1
 45 | #define PRONTO_IR_SOURCE 0 // Pronto code byte 0
 46 | #define PRONTO_FREQ_CODE 1 // Pronto code byte 1
 47 | #define PRONTO_SEQUENCE1_LENGTH 2 // Pronto code byte 2
 48 | #define PRONTO_SEQUENCE2_LENGTH 3 // Pronto code byte 3
 49 | #define PRONTO_CODE_START 4 // Pronto code byte 4
 50 | 
 51 | static const uint16_t *ir_code = NULL;
 52 | static uint16_t ir_cycle_count = 0;
 53 | static uint32_t ir_total_cycle_count = 0;
 54 | static uint8_t ir_seq_index = 0;
 55 | static uint8_t ir_led_state = 0;
 56 | 
 57 | void ir_on()
 58 | {
 59 |   IR_TCCRnA |= (1<<IR_COMn1) + (1<<IR_COMn0);
 60 |   ir_led_state = 1;
 61 | }
 62 | 
 63 | void ir_off()
 64 | {
 65 |   IR_TCCRnA &= ((~(1<<IR_COMn1)) & (~(1<<IR_COMn0)) );
 66 |   ir_led_state = 0;
 67 | }
 68 | 
 69 | void ir_toggle()
 70 | {
 71 |   if (ir_led_state)
 72 |     ir_off();
 73 |   else
 74 |     ir_on();
 75 | }
 76 | 
 77 | void ir_start(uint16_t *code)
 78 | {
 79 |   ir_code = code;
 80 | //  IR_PORT &= ~IR_BV; // Turn output off (atmega328 only)
 81 |   digitalWrite(9,LOW); // Turn output off
 82 | //  IR_DDR |= IR_BV; // Set it as output (atmega328 only)
 83 |   pinMode(9,OUTPUT); // Set it as output
 84 |   IR_TCCRnA = 0x00; // Reset the pwm
 85 |   IR_TCCRnB = 0x00;
 86 |   //printf_P(PSTR("FREQ CODE: %hd\r\n"), code[PRONTO_FREQ_CODE]);
 87 |   uint16_t top = ( (F_CPU/1000000.0) * code[PRONTO_FREQ_CODE] * 0.241246 ) - 1;
 88 |   //printf_P(PSTR("top: %hu\n\r"), top);
 89 |   IR_ICRn = top;
 90 |   IR_OCRn = top >> 1;
 91 |   IR_TCCRnA = (1<<WGM11);
 92 |   IR_TCCRnB = (1<<WGM13) | (1<<WGM12);
 93 |   IR_TCNTn = 0x0000;
 94 |   IR_TIFRn = 0x00;
 95 |   IR_TIMSKn = 1 << IR_TOIEn;
 96 |   ir_seq_index = PRONTO_CODE_START;
 97 |   ir_cycle_count = 0;
 98 |   ir_on();
 99 |   IR_TCCRnB |= (1<<CS10);
100 | }
101 | 
102 | #define TOTAL_CYCLES 80000 // Turns off after this number of
103 | // cycles. About 2 seconds
104 | // FIXME: Turn off after having sent
105 | ISR(TIMER1_OVF_vect) {
106 |   uint16_t sequenceIndexEnd;
107 |   uint16_t repeatSequenceIndexStart;
108 |   ir_total_cycle_count++;
109 |   ir_cycle_count++;
110 | 
111 |   if (ir_cycle_count== ir_code[ir_seq_index]) {
112 |     ir_toggle();
113 |     ir_cycle_count = 0;
114 |     ir_seq_index++;
115 |     sequenceIndexEnd = PRONTO_CODE_START +
116 |       (ir_code[PRONTO_SEQUENCE1_LENGTH]<<1) +
117 |       (ir_code[PRONTO_SEQUENCE2_LENGTH]<<1);
118 | 
119 |     repeatSequenceIndexStart = PRONTO_CODE_START +
120 |       (ir_code[PRONTO_SEQUENCE1_LENGTH]<<1);
121 | 
122 |     if (ir_seq_index >= sequenceIndexEnd ) {
123 |       ir_seq_index = repeatSequenceIndexStart;
124 | 
125 |       if(ir_total_cycle_count>TOTAL_CYCLES) {
126 |         ir_off();
127 |         TCCR1B &= ~(1<<CS10);
128 |       }
129 |     }
130 |   }
131 | }
132 | 
133 | void ir_stop()
134 | {
135 |   IR_TCCRnA = 0x00; // Reset the pwm
136 |   IR_TCCRnB = 0x00;
137 | }
138 | 
139 | const uint16_t inputLength = 512;
140 | 
141 | void setup() {
142 |   Serial.begin(9600);
143 |   Serial.println("READY");
144 | }
145 | 
146 | void loop()
147 | {
148 |   if ( Serial.available() > 0 )
149 |   {
150 |     static char input[inputLength];
151 |     static uint16_t i;
152 |     char c = Serial.read();
153 | 
154 |     if ( c != '\r' && c != '\n' && i < inputLength-1)
155 |       input[i++] = c;
156 | 
157 |     else
158 |     {
159 |       input[i] = '\0';
160 |       i = 0;
161 | 
162 |       uint16_t array[80];
163 |       uint16_t j = 0;
164 | 
165 |       if ( !strncmp(input, "SEND", 4) )
166 |       {
167 |         char* p = input+4;
168 | 
169 |         while ( (p = strchr(p, ' ')) != NULL )
170 |           array[j++] = strtol(p, &p, 16);
171 | 
172 |         ir_start(array);
173 |         Serial.print("SENT ");
174 |         for ( uint8_t i = 0; i < j; i++ )
175 |         {
176 |           Serial.print ("0x");
177 |           Serial.print (array[i], HEX);
178 |           Serial.print(" ");
179 |         }
180 | 
181 | 
182 |         Serial.println();
183 |       }
184 |     }
185 |   }
186 | }
187 | 


--------------------------------------------------------------------------------