removed pronto support for the moment

library

.gitignore

@@ -0,0 +1,4 @@
+*.un~
+*.sublime-project
+*.sublime-workspace
+*.DS_Store

Contributing.md

@@ -0,0 +1,11 @@
+# Contribution Guidlines
+
+This library is the culmination of the expertise of many members of the open source community who have dedicated their time and hard work. The best way to ask for help or propose a new idea is to [create a new issue](https://github.com/z3t0/Arduino-IRremote/issues/new) while creating a Pull Request with your code changes allows you to share your own innovations with the rest of the community.
+
+The following are some guidelines to observe when creating issues or PRs:
+- Be friendly; it is important that we can all enjoy a safe space as we are all working on the same project and it is okay for people to have different ideas
+- [Use code blocks](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#code); it helps us help you when we can read your code! On that note also refrain from pasting more than 30 lines of code in a post, instead [create a gist](https://gist.github.com/) if you need to share large snippets
+- Use reasonable titles; refrain from using overly long or capitalized titles as they are usually annoying and do little to encourage others to help :smile:
+- Be detailed; refrain from mentioning code problems without sharing your source code and always give information regarding your board and version of the library 
+
+If there is any need to contact me then you can find my email on the README, I do not mind responding to emails but it would be in your own interests to create issues if you need help with the library as responses would be from a larger community with greater knowledge!

Contributors.md

@@ -1,16 +1,21 @@
 ## Contributors
-These are the active contributors of this project that you may contact if there is anything you need help with or if you have suggestions. 
+These are the active contributors of this project that you may contact if there is anything you need help with or if you have suggestions.
 
 - [z3t0](https://github.com/z3t0) : Active Contributor and currently also the main contributor.
   * Email: zetoslab@gmail.com
   * Skype: polarised16
-- [shirriff](https://github.com/shirriff) : Owner of repository and creator of library.
+- [shirriff](https://github.com/shirriff) : An amazing person who worked to create this awesome library and provide unending support
 - [Informatic](https://github.com/Informatic) : Active contributor
 - [fmeschia](https://github.com/fmeschia) : Active contributor
 - [PaulStoffregen](https://github.com/paulstroffregen) : Active contributor
 - [crash7](https://github.com/crash7) : Active contributor
 - [Neco777](https://github.com/neco777) : Active contributor
+- [Lauszus](https://github.com/lauszus) : Active contributor
+- [csBlueChip](https://github.com/csbluechip) : Active contributor, who contributed major and vital changes to the code base.
+- [Sebazzz](https://github.com/sebazz): Contributor
+- [lumbric](https://github.com/lumbric): Contributor
+- [ElectricRCAircraftGuy](https://github.com/electricrcaircraftguy): Active Contributor
+- [henkel](https://github.com/henkel): Contributor
+- [MCUdude](https://github.com/MCUdude): Contributor
 
 Note: This list is being updated constantly so please let [z3t0](https://github.com/z3t0) know if you have been missed.
-
-

IRremote.h

@@ -1,130 +1,344 @@
-/*
- * IRremote
- * Version 0.1 July, 2009
- * Copyright 2009 Ken Shirriff
- * For details, see http://arcfn.com/2009/08/multi-protocol-infrared-remote-library.htm http://arcfn.com
- * Edited by Mitra to add new controller SANYO
- *
- * Interrupt code based on NECIRrcv by Joe Knapp
- * http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1210243556
- * Also influenced by http://zovirl.com/2008/11/12/building-a-universal-remote-with-an-arduino/
- *
- * JVC and Panasonic protocol added by Kristian Lauszus (Thanks to zenwheel and other people at the original blog post)
- * LG added by Darryl Smith (based on the JVC protocol)
- * Whynter A/C ARC-110WD added by Francesco Meschia
- */
+
+//******************************************************************************
+// IRremote
+// Version 2.0.1 June, 2015
+// Copyright 2009 Ken Shirriff
+// For details, see http://arcfn.com/2009/08/multi-protocol-infrared-remote-library.html
+// Edited by Mitra to add new controller SANYO
+//
+// Interrupt code based on NECIRrcv by Joe Knapp
+// http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1210243556
+// Also influenced by http://zovirl.com/2008/11/12/building-a-universal-remote-with-an-arduino/
+//
+// JVC and Panasonic protocol added by Kristian Lauszus (Thanks to zenwheel and other people at the original blog post)
+// LG added by Darryl Smith (based on the JVC protocol)
+// Whynter A/C ARC-110WD added by Francesco Meschia
+//******************************************************************************
 
 #ifndef IRremote_h
 #define IRremote_h
 
-// The following are compile-time library options.
-// If you change them, recompile the library.
-// If DEBUG is defined, a lot of debugging output will be printed during decoding.
-// TEST must be defined for the IRtest unittests to work.  It will make some
-// methods virtual, which will be slightly slower, which is why it is optional.
-//#define DEBUG
-// #define TEST
+//------------------------------------------------------------------------------
+// The ISR header contains several useful macros the user may wish to use
+//
+#include "IRremoteInt.h"
 
+//------------------------------------------------------------------------------
+// Supported IR protocols
+// Each protocol you include costs memory and, during decode, costs time
+// Disable (set to 0) all the protocols you do not need/want!
+//
+#define DECODE_RC5           1
+#define SEND_RC5             1
+
+#define DECODE_RC6           1
+#define SEND_RC6             1
+
+#define DECODE_NEC           1
+#define SEND_NEC             1
+
+#define DECODE_SONY          1
+#define SEND_SONY            1
+
+#define DECODE_PANASONIC     1
+#define SEND_PANASONIC       1
+
+#define DECODE_JVC           1
+#define SEND_JVC             1
+
+#define DECODE_SAMSUNG       1
+#define SEND_SAMSUNG         1
+
+#define DECODE_WHYNTER       1
+#define SEND_WHYNTER         1
+
+#define DECODE_AIWA_RC_T501  1
+#define SEND_AIWA_RC_T501    1
+
+#define DECODE_LG            1
+#define SEND_LG              1
+
+#define DECODE_SANYO         1
+#define SEND_SANYO           0 // NOT WRITTEN
+
+#define DECODE_MITSUBISHI    1
+#define SEND_MITSUBISHI      0 // NOT WRITTEN
+
+#define DECODE_DISH          0 // NOT WRITTEN
+#define SEND_DISH            1
+
+#define DECODE_SHARP         0 // NOT WRITTEN
+#define SEND_SHARP           1
+
+#define DECODE_DENON         1
+#define SEND_DENON           1
+
+#define DECODE_PRONTO        0 // This function doe not logically make sense
+#define SEND_PRONTO          1
+
+#define DECODE_LEGO_PF       0 // NOT WRITTEN
+#define SEND_LEGO_PF         1
+
+//------------------------------------------------------------------------------
+// When sending a Pronto code we request to send either the "once" code
+//                                                   or the "repeat" code
+// If the code requested does not exist we can request to fallback on the
+// other code (the one we did not explicitly request)
+//
+// I would suggest that "fallback" will be the standard calling method
+// The last paragraph on this page discusses the rationale of this idea:
+//   http://www.remotecentral.com/features/irdisp2.htm
+//
+#define PRONTO_ONCE        false
+#define PRONTO_REPEAT      true
+#define PRONTO_FALLBACK    true
+#define PRONTO_NOFALLBACK  false
+
+//------------------------------------------------------------------------------
+// An enumerated list of all supported formats
+// You do NOT need to remove entries from this list when disabling protocols!
+//
+typedef
+	enum {
+		UNKNOWN      = -1,
+		UNUSED       =  0,
+		RC5,
+		RC6,
+		NEC,
+		SONY,
+		PANASONIC,
+		JVC,
+		SAMSUNG,
+		WHYNTER,
+		AIWA_RC_T501,
+		LG,
+		SANYO,
+		MITSUBISHI,
+		DISH,
+		SHARP,
+		DENON,
+		PRONTO,
+		LEGO_PF,
+	}
+decode_type_t;
+
+//------------------------------------------------------------------------------
+// Set DEBUG to 1 for lots of lovely debug output
+//
+#define DEBUG  0
+
+//------------------------------------------------------------------------------
+// Debug directives
+//
+#if DEBUG
+#	define DBG_PRINT(...)    Serial.print(__VA_ARGS__)
+#	define DBG_PRINTLN(...)  Serial.println(__VA_ARGS__)
+#else
+#	define DBG_PRINT(...)
+#	define DBG_PRINTLN(...)
+#endif
+
+//------------------------------------------------------------------------------
+// Mark & Space matching functions
+//
+int  MATCH       (int measured, int desired) ;
+int  MATCH_MARK  (int measured_ticks, int desired_us) ;
+int  MATCH_SPACE (int measured_ticks, int desired_us) ;
+
+//------------------------------------------------------------------------------
 // Results returned from the decoder
-class decode_results {
-public:
-  int decode_type; // NEC, SONY, RC5, UNKNOWN
-  union { // This is used for decoding Panasonic and Sharp data
-    unsigned int panasonicAddress;
-    unsigned int sharpAddress;
-  };
-  unsigned long value; // Decoded value
-  int bits; // Number of bits in decoded value
-  volatile unsigned int *rawbuf; // Raw intervals in .5 us ticks
-  int rawlen; // Number of records in rawbuf.
+//
+class decode_results
+{
+	public:
+		decode_type_t          decode_type;  // UNKNOWN, NEC, SONY, RC5, ...
+		unsigned int           address;      // Used by Panasonic & Sharp [16-bits]
+		unsigned long          value;        // Decoded value [max 32-bits]
+		int                    bits;         // Number of bits in decoded value
+		volatile unsigned int  *rawbuf;      // Raw intervals in 50uS ticks
+		int                    rawlen;       // Number of records in rawbuf
+		int                    overflow;     // true iff IR raw code too long
 };
 
-// Values for decode_type
-#define NEC 1
-#define SONY 2
-#define RC5 3
-#define RC6 4
-#define DISH 5
-#define SHARP 6
-#define PANASONIC 7
-#define JVC 8
-#define SANYO 9
-#define MITSUBISHI 10
-#define SAMSUNG 11
-#define LG 12
-#define WHYNTER 13
-#define UNKNOWN -1
-
+//------------------------------------------------------------------------------
 // Decoded value for NEC when a repeat code is received
-#define REPEAT 0xffffffff
+//
+#define REPEAT 0xFFFFFFFF
 
-// main class for receiving IR
+//------------------------------------------------------------------------------
+// Main class for receiving IR
+//
 class IRrecv
 {
-public:
-  IRrecv(int recvpin);
-  void blink13(int blinkflag);
-  int decode(decode_results *results);
-  void enableIRIn();
-  void resume();
-private:
-  // These are called by decode
-  int getRClevel(decode_results *results, int *offset, int *used, int t1);
-  long decodeNEC(decode_results *results);
-  long decodeSony(decode_results *results);
-  long decodeSanyo(decode_results *results);
-  long decodeMitsubishi(decode_results *results);
-  long decodeRC5(decode_results *results);
-  long decodeRC6(decode_results *results);
-  long decodePanasonic(decode_results *results);
-  long decodeLG(decode_results *results);
-  long decodeJVC(decode_results *results);
-  long decodeSAMSUNG(decode_results *results);
-  long decodeWhynter(decode_results *results);
-  long decodeHash(decode_results *results);
-  int compare(unsigned int oldval, unsigned int newval);
+	public:
+		IRrecv (int recvpin) ;
+		IRrecv (int recvpin, int blinkpin);
 
+		void  blink13    (int blinkflag) ;
+		int   decode     (decode_results *results) ;
+		void  enableIRIn ( ) ;
+		bool  isIdle     ( ) ;
+		void  resume     ( ) ;
+
+	private:
+		long  decodeHash (decode_results *results) ;
+		int   compare    (unsigned int oldval, unsigned int newval) ;
+
+		//......................................................................
+#		if (DECODE_RC5 || DECODE_RC6)
+			// This helper function is shared by RC5 and RC6
+			int  getRClevel (decode_results *results,  int *offset,  int *used,  int t1) ;
+#		endif
+#		if DECODE_RC5
+			bool  decodeRC5        (decode_results *results) ;
+#		endif
+#		if DECODE_RC6
+			bool  decodeRC6        (decode_results *results) ;
+#		endif
+		//......................................................................
+#		if DECODE_NEC
+			bool  decodeNEC        (decode_results *results) ;
+#		endif
+		//......................................................................
+#		if DECODE_SONY
+			bool  decodeSony       (decode_results *results) ;
+#		endif
+		//......................................................................
+#		if DECODE_PANASONIC
+			bool  decodePanasonic  (decode_results *results) ;
+#		endif
+		//......................................................................
+#		if DECODE_JVC
+			bool  decodeJVC        (decode_results *results) ;
+#		endif
+		//......................................................................
+#		if DECODE_SAMSUNG
+			bool  decodeSAMSUNG    (decode_results *results) ;
+#		endif
+		//......................................................................
+#		if DECODE_WHYNTER
+			bool  decodeWhynter    (decode_results *results) ;
+#		endif
+		//......................................................................
+#		if DECODE_AIWA_RC_T501
+			bool  decodeAiwaRCT501 (decode_results *results) ;
+#		endif
+		//......................................................................
+#		if DECODE_LG
+			bool  decodeLG         (decode_results *results) ;
+#		endif
+		//......................................................................
+#		if DECODE_SANYO
+			bool  decodeSanyo      (decode_results *results) ;
+#		endif
+		//......................................................................
+#		if DECODE_MITSUBISHI
+			bool  decodeMitsubishi (decode_results *results) ;
+#		endif
+		//......................................................................
+#		if DECODE_DISH
+			bool  decodeDish (decode_results *results) ; // NOT WRITTEN
+#		endif
+		//......................................................................
+#		if DECODE_SHARP
+			bool  decodeSharp (decode_results *results) ; // NOT WRITTEN
+#		endif
+		//......................................................................
+#		if DECODE_DENON
+			bool  decodeDenon (decode_results *results) ;
+#		endif
+//......................................................................
+#		if DECODE_LEGO_PF
+			bool  decodeLegoPowerFunctions (decode_results *results) ;
+#		endif
 } ;
 
-// Only used for testing; can remove virtual for shorter code
-#ifdef TEST
-#define VIRTUAL virtual
-#else
-#define VIRTUAL
-#endif
-
+//------------------------------------------------------------------------------
+// Main class for sending IR
+//
 class IRsend
 {
-public:
-  IRsend() {}
-  void sendWhynter(unsigned long data, int nbits);
-  void sendNEC(unsigned long data, int nbits);
-  void sendSony(unsigned long data, int nbits);
-  // Neither Sanyo nor Mitsubishi send is implemented yet
-  //  void sendSanyo(unsigned long data, int nbits);
-  //  void sendMitsubishi(unsigned long data, int nbits);
-  void sendRaw(unsigned int buf[], int len, int hz);
-  void sendRC5(unsigned long data, int nbits);
-  void sendRC6(unsigned long data, int nbits);
-  void sendDISH(unsigned long data, int nbits);
-  void sendSharp(unsigned int address, unsigned int command);
-  void sendSharpRaw(unsigned long data, int nbits);
-  void sendPanasonic(unsigned int address, unsigned long data);
-  void sendJVC(unsigned long data, int nbits, int repeat); // *Note instead of sending the REPEAT constant if you want the JVC repeat signal sent, send the original code value and change the repeat argument from 0 to 1. JVC protocol repeats by skipping the header NOT by sending a separate code value like NEC does.
-  // private:
-  void sendSAMSUNG(unsigned long data, int nbits);
-  void enableIROut(int khz);
-  VIRTUAL void mark(int usec);
-  VIRTUAL void space(int usec);
+	public:
+		IRsend () { }
+
+		void  custom_delay_usec (unsigned long uSecs);
+		void  enableIROut 		(int khz) ;
+		void  mark        		(unsigned int usec) ;
+		void  space       		(unsigned int usec) ;
+		void  sendRaw     		(const unsigned int buf[],  unsigned int len,  unsigned int hz) ;
+
+		//......................................................................
+#		if SEND_RC5
+			void  sendRC5        (unsigned long data,  int nbits) ;
+#		endif
+#		if SEND_RC6
+			void  sendRC6        (unsigned long data,  int nbits) ;
+#		endif
+		//......................................................................
+#		if SEND_NEC
+			void  sendNEC        (unsigned long data,  int nbits) ;
+#		endif
+		//......................................................................
+#		if SEND_SONY
+			void  sendSony       (unsigned long data,  int nbits) ;
+#		endif
+		//......................................................................
+#		if SEND_PANASONIC
+			void  sendPanasonic  (unsigned int address,  unsigned long data) ;
+#		endif
+		//......................................................................
+#		if SEND_JVC
+			// JVC does NOT repeat by sending a separate code (like NEC does).
+			// The JVC protocol repeats by skipping the header.
+			// To send a JVC repeat signal, send the original code value
+			//   and set 'repeat' to true
+			void  sendJVC        (unsigned long data,  int nbits,  bool repeat) ;
+#		endif
+		//......................................................................
+#		if SEND_SAMSUNG
+			void  sendSAMSUNG    (unsigned long data,  int nbits) ;
+#		endif
+		//......................................................................
+#		if SEND_WHYNTER
+			void  sendWhynter    (unsigned long data,  int nbits) ;
+#		endif
+		//......................................................................
+#		if SEND_AIWA_RC_T501
+			void  sendAiwaRCT501 (int code) ;
+#		endif
+		//......................................................................
+#		if SEND_LG
+			void  sendLG         (unsigned long data,  int nbits) ;
+#		endif
+		//......................................................................
+#		if SEND_SANYO
+			void  sendSanyo      ( ) ; // NOT WRITTEN
+#		endif
+		//......................................................................
+#		if SEND_MISUBISHI
+			void  sendMitsubishi ( ) ; // NOT WRITTEN
+#		endif
+		//......................................................................
+#		if SEND_DISH
+			void  sendDISH       (unsigned long data,  int nbits) ;
+#		endif
+		//......................................................................
+#		if SEND_SHARP
+			void  sendSharpRaw   (unsigned long data,  int nbits) ;
+			void  sendSharp      (unsigned int address,  unsigned int command) ;
+#		endif
+		//......................................................................
+#		if SEND_DENON
+			void  sendDenon      (unsigned long data,  int nbits) ;
+#		endif
+		//......................................................................
+#		if SEND_PRONTO
+			void  sendPronto     (char* code,  bool repeat,  bool fallback) ;
+#		endif
+//......................................................................
+#		if SEND_LEGO_PF
+			void  sendLegoPowerFunctions (uint16_t data, bool repeat = true) ;
+#		endif
 } ;
 
-// Some useful constants
-
-#define USECPERTICK 50  // microseconds per clock interrupt tick
-#define RAWBUF 100 // Length of raw duration buffer
-
-// Marks tend to be 100us too long, and spaces 100us too short
-// when received due to sensor lag.
-#define MARK_EXCESS 100
-
 #endif

ISSUE_TEMPLATE.md

@@ -0,0 +1,21 @@
+**Board:** ARDUINO UNO
+**Library Version:** 2.1.0
+**Protocol:** Sony (if any)
+
+**Code Block:**
+```c
+
+#include <IRremote.h> 
+
+.....
+
+```
+
+Use [a gist](gist.github.com) if the code exceeds 30 lines
+
+**checklist:**
+- [] The latest [release](https://github.com/z3t0/Arduino-IRremote/releases/latest) is used
+- [] Any code referenced is provided
+- [] The title of the issue is helpful and relevant 
+
+The above is a short template allowing you to make detailed issues!

README.md

@@ -1,15 +1,72 @@
 # IRremote Arduino Library
-This library enables you to send and receive using infra-red signals on an arduino.
 
-Check [here](http://shirriff.github.io/Arduino-IRremote/) for tutorials and more information.
+# todo
 
-## Version - 1.00
+- [ ] only keep base functions in the library
+- [ ] move all protocols to examples as sketches
+- [ ] notation for ir protocols
+- [ ] update keywords.txt
+- [ ] write some documentation on library development
+- [ ] write documentation for library usage
+- [ ] remove documentation from source code? cleaner code
+- [ ] write tutorials
+- [ ] update links (library.properties)
+- [ ] update travis coverage
+- [ ] create a rules list for issues and prs
+- [ ] create guidlines for contributions, line-endings, indentations etc.
+
+[![Build Status](https://travis-ci.org/z3t0/Arduino-IRremote.svg?branch=master)](https://travis-ci.org/z3t0/Arduino-IRremote)
+
+[![Join the chat at https://gitter.im/z3t0/Arduino-IRremote](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/z3t0/Arduino-IRremote?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+This library enables you to send and receive using infra-red signals on an Arduino.
+
+Tutorials and more information will be made available on [the official homepage](http://z3t0.github.io/Arduino-IRremote/).
+
+## Version - 3.0.0b
 
 ## Installation
-1. Navigate to the [Releases](https://github.com/shirriff/Arduino-IRremote/releases) page.
+1. Navigate to the [Releases](https://github.com/z3t0/Arduino-IRremote/releases) page.
 2. Download the latest release.
 3. Extract the zip file
 4. Move the "IRremote" folder that has been extracted to your libraries directory.
+5. Make sure to delete Arduino_Root/libraries/RobotIRremote. Where Arduino_Root refers to the install directory of Arduino. The library RobotIRremote has similar definitions to IRremote and causes errors.
+
+## Supported Boards
+- Arduino Uno / Mega / Leonardo / Duemilanove / Diecimila / LilyPad / Mini / Fio / Nano etc.
+- Teensy 1.0 / 1.0++ / 2.0 / 2++ / 3.0 / 3.1 / Teensy-LC; Credits: @PaulStoffregen (Teensy Team)
+- Sanguino
+- ATmega8, 48, 88, 168, 328
+- ATmega8535, 16, 32, 164, 324, 644, 1284,
+- ATmega64, 128
+- ATtiny 84 / 85
+
+We are open to suggestions for adding support to new boards, however we highly recommend you contact your supplier first and ask them to provide support from their side.
+
+### Hardware specifications
+
+| Board/CPU                                                                | Send Pin            | Timers            |
+|--------------------------------------------------------------------------|---------------------|-------------------|
+| [ATtiny84](https://github.com/SpenceKonde/ATTinyCore)                    | **6**               | **1**             |
+| [ATtiny85](https://github.com/SpenceKonde/ATTinyCore)                    | **1**               | **TINY0**         |
+| [ATmega8](https://github.com/MCUdude/MiniCore)                           | **9**               | **1**             |
+| Atmega32u4                                                               | 5, 9, **13**        | 1, 3, **4**       |
+| [ATmega48, ATmega88, ATmega168, ATmega328](https://github.com/MCUdude/MiniCore) | **3**, 9     | 1, **2**          |
+| [ATmega1284](https://github.com/MCUdude/MightyCore)                      | 13, 14, 6           | 1, **2**, 3       |
+| [ATmega164, ATmega324, ATmega644](https://github.com/MCUdude/MightyCore) | 13, **14**          | 1, **2**          |
+| [ATmega8535 ATmega16, ATmega32](https://github.com/MCUdude/MightyCore)   | **13**              | **1**             |
+| [ATmega64, ATmega128](https://github.com/MCUdude/MegaCore)               | **13**              | **1**             |
+| ATmega1280, ATmega2560                                                   | 5, 6, **9**, 11, 46 | 1, **2**, 3, 4, 5 |
+| [Teensy 1.0](https://www.pjrc.com/teensy/)                               | **17**              | **1**             |
+| [Teensy 2.0](https://www.pjrc.com/teensy/)                               | 9, **10**, 14       | 1, 3, **4_HS**    |
+| [Teensy++ 1.0 / 2.0](https://www.pjrc.com/teensy/)                       | **1**, 16, 25       | 1, **2**, 3       |
+| [Teensy 3.0 / 3.1](https://www.pjrc.com/teensy/)                         | **5**               | **CMT**           |
+| [Teensy-LC](https://www.pjrc.com/teensy/)                                | **16**              | **TPM1**          |
+
+The table above lists the currently supported timers and corresponding send pins, many of these can have additional pins opened up and we are open to requests if a need arises for other pins.
+
+## Usage
+- TODO (Check examples for now)
 
 ## Contributing
 If you want to contribute to this project:
@@ -17,9 +74,17 @@ If you want to contribute to this project:
 - Ask for enhancements
 - Create issues and pull requests
 - Tell other people about this library
+- Contribute new protocols
+
+Check [here](Contributing.md) for some guidelines.
+
+## Contact
+The only way to contact me at the moment is by email: zetoslab@gmail.com
+I am not currently monitoring any PRs or Issues due to other issues but will respond to all emails. If anyone wants contributor access, feel free to email me. Or if you find any Issues/PRs to be of importance that my attention is needed please email me.
 
 ## Contributors
 Check [here](Contributors.md)
 
 ## Copyright
 Copyright 2009-2012 Ken Shirriff
+Copyright (c) 2016 Rafi Khan

changelog.md

@@ -0,0 +1,69 @@
+## 2.2.1 - 2016/07/27
+- Added tests for Lego Power Functions Protocol [PR #336](https://github.com/z3t0/Arduino-IRremote/pull/336)
+
+## 2.2.0 - 2016/06/28
+- Added support for ATmega8535
+- Added support for ATmega16
+- Added support for ATmega32
+- Added support for ATmega164
+- Added support for ATmega324
+- Added support for ATmega644
+- Added support for ATmega1284
+- Added support for ATmega64
+- Added support for ATmega128
+
+[PR](https://github.com/z3t0/Arduino-IRremote/pull/324)
+
+## 2.1.1 - 2016/05/04
+- Added Lego Power Functions Protocol [PR #309](https://github.com/z3t0/Arduino-IRremote/pull/309)
+
+## 2.1.0 - 2016/02/20
+- Improved Debugging [PR #258](https://github.com/z3t0/Arduino-IRremote/pull/258)
+- Display TIME instead of TICKS [PR #258](https://github.com/z3t0/Arduino-IRremote/pull/258)
+
+## 2.0.4 - 2016/02/20
+- Add Panasonic and JVC to IRrecord example [PR](https://github.com/z3t0/Arduino-IRremote/pull/54)
+
+## 2.0.3 - 2016/02/20
+- Change IRSend Raw parameter to const [PR](https://github.com/z3t0/Arduino-IRremote/pull/227)
+
+## 2.0.2 - 2015/12/02
+- Added IRremoteInfo Sketch - [PR](https://github.com/z3t0/Arduino-IRremote/pull/241)
+- Enforcing changelog.md
+
+## 2.0.1 - 2015/07/26 - [Release](https://github.com/shirriff/Arduino-IRremote/releases/tag/BETA)
+### Changes
+- Updated README
+- Updated Contributors
+- Fixed #110 Mess
+- Created Gitter Room
+- Added Gitter Badge
+- Standardised Code Base
+- Clean Debug Output
+- Optimized Send Loops
+- Modularized Design
+- Optimized and Updated Examples
+- Improved Documentation
+- Fixed and Improved many coding errors
+- Fixed Aiwa RC-T501 Decoding
+- Fixed Interrupt on ATmega8
+- Switched to Stable Release of @PlatformIO
+
+### Additions
+- Added Aiwa RC-T501 Protocol
+- Added Denon Protocol
+- Added Pronto Support
+- Added Library Properties
+- Added Template For New Protocols
+- Added this changelog
+- Added Teensy LC Support
+- Added ATtiny84 Support
+- Added ATtiny85 Support
+- Added isIdle method
+
+### Deletions
+- Removed (Fixed) #110
+- Broke Teensy 3 / 3.1 Support
+
+### Not Working
+- Teensy 3 / 3.1 Support is in Development

examples/AiwaRCT501SendDemo/AiwaRCT501SendDemo.ino

@@ -0,0 +1,26 @@
+/*
+ * IRremote: IRsendDemo - demonstrates sending IR codes with IRsend
+ * An IR LED must be connected to Arduino PWM pin 3.
+ * Version 0.1 July, 2009
+ * Copyright 2009 Ken Shirriff
+ * http://arcfn.com
+ */
+
+#include "IRremote.h"
+
+#define POWER 0x7F80
+#define AIWA_RC_T501
+
+IRsend irsend;
+
+void setup() {
+  Serial.begin(9600);
+  Serial.println("Arduino Ready");
+}
+
+void loop() {
+  if (Serial.read() != -1) {
+    irsend.sendAiwaRCT501(POWER);
+    delay(60); // Optional
+  }
+}

examples/IRrecord/IRrecord.ino

@@ -80,6 +80,12 @@ void storeCode(decode_results *results) {
     else if (codeType == SONY) {
       Serial.print("Received SONY: ");
     } 
+    else if (codeType == PANASONIC) {
+      Serial.print("Received PANASONIC: ");
+    }
+    else if (codeType == JVC) {
+      Serial.print("Received JVC: ");
+    }
     else if (codeType == RC5) {
       Serial.print("Received RC5: ");
     } 
@@ -114,6 +120,16 @@ void sendCode(int repeat) {
     Serial.print("Sent Sony ");
     Serial.println(codeValue, HEX);
   } 
+  else if (codeType == PANASONIC) {
+    irsend.sendPanasonic(codeValue, codeLen);
+    Serial.print("Sent Panasonic");
+    Serial.println(codeValue, HEX);
+  }
+  else if (codeType == JVC) {
+    irsend.sendPanasonic(codeValue, codeLen);
+    Serial.print("Sent JVC");
+    Serial.println(codeValue, HEX);
+  }
   else if (codeType == RC5 || codeType == RC6) {
     if (!repeat) {
       // Flip the toggle bit for a new button press

examples/IRrecvDump/IRrecvDump.ino

@@ -10,7 +10,12 @@
 
 #include <IRremote.h>
 
-int RECV_PIN = 11;
+/* 
+*  Default is Arduino pin D11. 
+*  You can change this to another available Arduino Pin.
+*  Your IR receiver should be connected to the pin defined here
+*/
+int RECV_PIN = 11; 
 
 IRrecv irrecv(RECV_PIN);
 
@@ -22,41 +27,43 @@ void setup()
   irrecv.enableIRIn(); // Start the receiver
 }
 
-// Dumps out the decode_results structure.
-// Call this after IRrecv::decode()
-// void * to work around compiler issue
-//void dump(void *v) {
-//  decode_results *results = (decode_results *)v
+
 void dump(decode_results *results) {
+  // Dumps out the decode_results structure.
+  // Call this after IRrecv::decode()
   int count = results->rawlen;
   if (results->decode_type == UNKNOWN) {
     Serial.print("Unknown encoding: ");
-  } 
+  }
   else if (results->decode_type == NEC) {
     Serial.print("Decoded NEC: ");
-  } 
+
+  }
   else if (results->decode_type == SONY) {
     Serial.print("Decoded SONY: ");
-  } 
+  }
   else if (results->decode_type == RC5) {
     Serial.print("Decoded RC5: ");
-  } 
+  }
   else if (results->decode_type == RC6) {
     Serial.print("Decoded RC6: ");
   }
-  else if (results->decode_type == PANASONIC) {	
+  else if (results->decode_type == PANASONIC) {
     Serial.print("Decoded PANASONIC - Address: ");
-    Serial.print(results->panasonicAddress,HEX);
+    Serial.print(results->address, HEX);
     Serial.print(" Value: ");
   }
   else if (results->decode_type == LG) {
-     Serial.print("Decoded LG: ");
+    Serial.print("Decoded LG: ");
   }
   else if (results->decode_type == JVC) {
-     Serial.print("Decoded JVC: ");
+    Serial.print("Decoded JVC: ");
+  }
+  else if (results->decode_type == AIWA_RC_T501) {
+    Serial.print("Decoded AIWA RC T501: ");
   }
   else if (results->decode_type == WHYNTER) {
-     Serial.print("Decoded Whynter: ");
+    Serial.print("Decoded Whynter: ");
   }
   Serial.print(results->value, HEX);
   Serial.print(" (");
@@ -66,19 +73,19 @@ void dump(decode_results *results) {
   Serial.print(count, DEC);
   Serial.print("): ");
 
-  for (int i = 0; i < count; i++) {
-    if ((i % 2) == 1) {
+  for (int i = 1; i < count; i++) {
+    if (i & 1) {
       Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
-    } 
+    }
     else {
-      Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);
+      Serial.write('-');
+      Serial.print((unsigned long) results->rawbuf[i]*USECPERTICK, DEC);
     }
     Serial.print(" ");
   }
-  Serial.println("");
+  Serial.println();
 }
 
-
 void loop() {
   if (irrecv.decode(&results)) {
     Serial.println(results.value, HEX);

examples/IRrecvDumpV2/IRrecvDumpV2.ino

@@ -0,0 +1,177 @@
+//------------------------------------------------------------------------------
+// Include the IRremote library header
+//
+#include <IRremote.h>
+
+//------------------------------------------------------------------------------
+// Tell IRremote which Arduino pin is connected to the IR Receiver (TSOP4838)
+//
+int recvPin = 11;
+IRrecv irrecv(recvPin);
+
+//+=============================================================================
+// Configure the Arduino
+//
+void  setup ( )
+{
+  Serial.begin(9600);   // Status message will be sent to PC at 9600 baud
+  irrecv.enableIRIn();  // Start the receiver
+}
+
+//+=============================================================================
+// Display IR code
+//
+void  ircode (decode_results *results)
+{
+  // Panasonic has an Address
+  if (results->decode_type == PANASONIC) {
+    Serial.print(results->address, HEX);
+    Serial.print(":");
+  }
+
+  // Print Code
+  Serial.print(results->value, HEX);
+}
+
+//+=============================================================================
+// Display encoding type
+//
+void  encoding (decode_results *results)
+{
+  switch (results->decode_type) {
+    default:
+    case UNKNOWN:      Serial.print("UNKNOWN");       break ;
+    case NEC:          Serial.print("NEC");           break ;
+    case SONY:         Serial.print("SONY");          break ;
+    case RC5:          Serial.print("RC5");           break ;
+    case RC6:          Serial.print("RC6");           break ;
+    case DISH:         Serial.print("DISH");          break ;
+    case SHARP:        Serial.print("SHARP");         break ;
+    case JVC:          Serial.print("JVC");           break ;
+    case SANYO:        Serial.print("SANYO");         break ;
+    case MITSUBISHI:   Serial.print("MITSUBISHI");    break ;
+    case SAMSUNG:      Serial.print("SAMSUNG");       break ;
+    case LG:           Serial.print("LG");            break ;
+    case WHYNTER:      Serial.print("WHYNTER");       break ;
+    case AIWA_RC_T501: Serial.print("AIWA_RC_T501");  break ;
+    case PANASONIC:    Serial.print("PANASONIC");     break ;
+    case DENON:        Serial.print("Denon");         break ;
+  }
+}
+
+//+=============================================================================
+// Dump out the decode_results structure.
+//
+void  dumpInfo (decode_results *results)
+{
+  // Check if the buffer overflowed
+  if (results->overflow) {
+    Serial.println("IR code too long. Edit IRremoteInt.h and increase RAWLEN");
+    return;
+  }
+
+  // Show Encoding standard
+  Serial.print("Encoding  : ");
+  encoding(results);
+  Serial.println("");
+
+  // Show Code & length
+  Serial.print("Code      : ");
+  ircode(results);
+  Serial.print(" (");
+  Serial.print(results->bits, DEC);
+  Serial.println(" bits)");
+}
+
+//+=============================================================================
+// Dump out the decode_results structure.
+//
+void  dumpRaw (decode_results *results)
+{
+  // Print Raw data
+  Serial.print("Timing[");
+  Serial.print(results->rawlen-1, DEC);
+  Serial.println("]: ");
+
+  for (int i = 1;  i < results->rawlen;  i++) {
+    unsigned long  x = results->rawbuf[i] * USECPERTICK;
+    if (!(i & 1)) {  // even
+      Serial.print("-");
+      if (x < 1000)  Serial.print(" ") ;
+      if (x < 100)   Serial.print(" ") ;
+      Serial.print(x, DEC);
+    } else {  // odd
+      Serial.print("     ");
+      Serial.print("+");
+      if (x < 1000)  Serial.print(" ") ;
+      if (x < 100)   Serial.print(" ") ;
+      Serial.print(x, DEC);
+      if (i < results->rawlen-1) Serial.print(", "); //',' not needed for last one
+    }
+    if (!(i % 8))  Serial.println("");
+  }
+  Serial.println("");                    // Newline
+}
+
+//+=============================================================================
+// Dump out the decode_results structure.
+//
+void  dumpCode (decode_results *results)
+{
+  // Start declaration
+  Serial.print("unsigned int  ");          // variable type
+  Serial.print("rawData[");                // array name
+  Serial.print(results->rawlen - 1, DEC);  // array size
+  Serial.print("] = {");                   // Start declaration
+
+  // Dump data
+  for (int i = 1;  i < results->rawlen;  i++) {
+    Serial.print(results->rawbuf[i] * USECPERTICK, DEC);
+    if ( i < results->rawlen-1 ) Serial.print(","); // ',' not needed on last one
+    if (!(i & 1))  Serial.print(" ");
+  }
+
+  // End declaration
+  Serial.print("};");  // 
+
+  // Comment
+  Serial.print("  // ");
+  encoding(results);
+  Serial.print(" ");
+  ircode(results);
+
+  // Newline
+  Serial.println("");
+
+  // Now dump "known" codes
+  if (results->decode_type != UNKNOWN) {
+
+    // Some protocols have an address
+    if (results->decode_type == PANASONIC) {
+      Serial.print("unsigned int  addr = 0x");
+      Serial.print(results->address, HEX);
+      Serial.println(";");
+    }
+
+    // All protocols have data
+    Serial.print("unsigned int  data = 0x");
+    Serial.print(results->value, HEX);
+    Serial.println(";");
+  }
+}
+
+//+=============================================================================
+// The repeating section of the code
+//
+void  loop ( )
+{
+  decode_results  results;        // Somewhere to store the results
+
+  if (irrecv.decode(&results)) {  // Grab an IR code
+    dumpInfo(&results);           // Output the results
+    dumpRaw(&results);            // Output the results in RAW format
+    dumpCode(&results);           // Output the results as source code
+    Serial.println("");           // Blank line between entries
+    irrecv.resume();              // Prepare for the next value
+  }
+}

examples/IRremoteInfo/IRremoteInfo.ino

@@ -0,0 +1,230 @@
+/*
+ * IRremote: IRremoteInfo - prints relevant config info & settings for IRremote over serial
+ * Intended to help identify & troubleshoot the various settings of IRremote
+ * For example, sometimes users are unsure of which pin is used for Tx or the RAWBUF values
+ * This example can be used to assist the user directly or with support.
+ * Intended to help identify & troubleshoot the various settings of IRremote
+ * Hopefully this utility will be a useful tool for support & troubleshooting for IRremote
+ * Check out the blog post describing the sketch via http://www.analysir.com/blog/2015/11/28/helper-utility-for-troubleshooting-irremote/
+ * Version 1.0 November 2015
+ * Original Author: AnalysIR - IR software & modules for Makers & Pros, visit http://www.AnalysIR.com
+ */
+
+
+#include <IRremote.h>
+
+void setup()
+{
+  Serial.begin(115200); //You may alter the BAUD rate here as needed
+  while (!Serial); //wait until Serial is established - required on some Platforms
+
+  //Runs only once per restart of the Arduino.
+  dumpHeader();
+  dumpRAWBUF();
+  dumpTIMER();
+  dumpTimerPin();
+  dumpClock();
+  dumpPlatform();
+  dumpPulseParams();
+  dumpSignalParams();
+  dumpArduinoIDE();
+  dumpDebugMode();
+  dumpProtocols();
+  dumpFooter();
+}
+
+void loop() {
+  //nothing to do!
+}
+
+void dumpRAWBUF() {
+  Serial.print(F("RAWBUF: "));
+  Serial.println(RAWBUF);
+}
+
+void dumpTIMER() {
+  boolean flag = false;
+#ifdef IR_USE_TIMER1
+  Serial.print(F("Timer defined for use: ")); Serial.println(F("Timer1")); flag = true;
+#endif
+#ifdef IR_USE_TIMER2
+  Serial.print(F("Timer defined for use: ")); Serial.println(F("Timer2")); flag = true;
+#endif
+#ifdef IR_USE_TIMER3
+  Serial.print(F("Timer defined for use: ")); Serial.println(F("Timer3")); flag = true;
+#endif
+#ifdef IR_USE_TIMER4
+  Serial.print(F("Timer defined for use: ")); Serial.println(F("Timer4")); flag = true;
+#endif
+#ifdef IR_USE_TIMER5
+  Serial.print(F("Timer defined for use: ")); Serial.println(F("Timer5")); flag = true;
+#endif
+#ifdef IR_USE_TIMER4_HS
+  Serial.print(F("Timer defined for use: ")); Serial.println(F("Timer4_HS")); flag = true;
+#endif
+#ifdef IR_USE_TIMER_CMT
+  Serial.print(F("Timer defined for use: ")); Serial.println(F("Timer_CMT")); flag = true;
+#endif
+#ifdef IR_USE_TIMER_TPM1
+  Serial.print(F("Timer defined for use: ")); Serial.println(F("Timer_TPM1")); flag = true;
+#endif
+#ifdef IR_USE_TIMER_TINY0
+  Serial.print(F("Timer defined for use: ")); Serial.println(F("Timer_TINY0")); flag = true;
+#endif
+
+  if (!flag) {
+    Serial.print(F("Timer Error: ")); Serial.println(F("not defined"));
+  }
+}
+
+void dumpTimerPin() {
+  Serial.print(F("IR Tx Pin: "));
+  Serial.println(TIMER_PWM_PIN);
+}
+
+void dumpClock() {
+  Serial.print(F("MCU Clock: "));
+  Serial.println(F_CPU);
+}
+
+void dumpPlatform() {
+  Serial.print(F("MCU Platform: "));
+
+#if defined(__AVR_ATmega1280__)
+  Serial.println(F("Arduino Mega1280"));
+#elif  defined(__AVR_ATmega2560__)
+  Serial.println(F("Arduino Mega2560"));
+#elif defined(__AVR_AT90USB162__)
+  Serial.println(F("Teensy 1.0 / AT90USB162"));
+  // Teensy 2.0
+#elif defined(__AVR_ATmega32U4__)
+  Serial.println(F("Arduino Leonardo / Yun / Teensy 1.0 / ATmega32U4"));
+#elif defined(__MK20DX128__) || defined(__MK20DX256__)
+  Serial.println(F("Teensy 3.0 / Teensy 3.1 / MK20DX128 / MK20DX256"));
+#elif defined(__MKL26Z64__)
+  Serial.println(F("Teensy-LC / MKL26Z64"));
+#elif defined(__AVR_AT90USB646__)
+  Serial.println(F("Teensy++ 1.0 / AT90USB646"));
+#elif defined(__AVR_AT90USB1286__)
+  Serial.println(F("Teensy++ 2.0 / AT90USB1286"));
+#elif defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)
+  Serial.println(F("ATmega1284"));
+#elif defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__)
+  Serial.println(F("ATmega644"));
+#elif defined(__AVR_ATmega324P__) || defined(__AVR_ATmega324A__) || defined(__AVR_ATmega324PA__)
+  Serial.println(F("ATmega324")); 
+#elif defined(__AVR_ATmega164A__) || defined(__AVR_ATmega164P__)
+  Serial.println(F("ATmega164"));
+#elif defined(__AVR_ATmega128__)
+  Serial.println(F("ATmega128"));
+#elif defined(__AVR_ATmega88__) || defined(__AVR_ATmega88P__)
+  Serial.println(F("ATmega88"));  
+#elif defined(__AVR_ATmega64__)
+  Serial.println(F("ATmega64"));
+#elif defined(__AVR_ATmega48__) || defined(__AVR_ATmega48P__)
+  Serial.println(F("ATmega48"));
+#elif defined(__AVR_ATmega32__)
+  Serial.println(F("ATmega32"));  
+#elif defined(__AVR_ATmega16__)
+  Serial.println(F("ATmega16"));
+#elif defined(__AVR_ATmega8535__)
+  Serial.println(F("ATmega8535"));  
+#elif defined(__AVR_ATmega8__)
+  Serial.println(F("Atmega8"));
+#elif defined(__AVR_ATtiny84__)
+  Serial.println(F("ATtiny84"));
+#elif defined(__AVR_ATtiny85__)
+  Serial.println(F("ATtiny85"));
+#else
+  Serial.println(F("ATmega328(P) / (Duemilanove, Diecimila, LilyPad, Mini, Micro, Fio, Nano, etc)"));
+#endif
+}
+
+void dumpPulseParams() {
+  Serial.print(F("Mark Excess: ")); Serial.print(MARK_EXCESS);; Serial.println(F(" uSecs"));
+  Serial.print(F("Microseconds per tick: ")); Serial.print(USECPERTICK);; Serial.println(F(" uSecs"));
+  Serial.print(F("Measurement tolerance: ")); Serial.print(TOLERANCE); Serial.println(F("%"));
+}
+
+void dumpSignalParams() {
+  Serial.print(F("Minimum Gap between IR Signals: ")); Serial.print(_GAP); Serial.println(F(" uSecs"));
+}
+
+void dumpDebugMode() {
+  Serial.print(F("Debug Mode: "));
+#if DEBUG
+  Serial.println(F("ON"));
+#else
+  Serial.println(F("OFF (Normal)"));
+#endif
+
+}
+
+void dumpArduinoIDE() {
+  Serial.print(F("Arduino IDE version: "));
+  Serial.print(ARDUINO / 10000);
+  Serial.write('.');
+  Serial.print((ARDUINO % 10000) / 100);
+  Serial.write('.');
+  Serial.println(ARDUINO % 100);
+}
+
+void dumpProtocols() {
+
+  Serial.println(); Serial.print(F("IR PROTOCOLS  "));  Serial.print(F("SEND     "));  Serial.println(F("DECODE"));
+  Serial.print(F("============= "));  Serial.print(F("======== "));  Serial.println(F("========"));
+  Serial.print(F("RC5:          "));  printSendEnabled(SEND_RC5);  printDecodeEnabled(DECODE_RC6);
+  Serial.print(F("RC6:          "));  printSendEnabled(SEND_RC6);  printDecodeEnabled(DECODE_RC5);
+  Serial.print(F("NEC:          "));  printSendEnabled(SEND_NEC);  printDecodeEnabled(DECODE_NEC);
+  Serial.print(F("SONY:         "));  printSendEnabled(SEND_SONY);  printDecodeEnabled(DECODE_SONY);
+  Serial.print(F("PANASONIC:    "));  printSendEnabled(SEND_PANASONIC);  printDecodeEnabled(DECODE_PANASONIC);
+  Serial.print(F("JVC:          "));  printSendEnabled(SEND_JVC);  printDecodeEnabled(DECODE_JVC);
+  Serial.print(F("SAMSUNG:      "));  printSendEnabled(SEND_SAMSUNG);  printDecodeEnabled(DECODE_SAMSUNG);
+  Serial.print(F("WHYNTER:      "));  printSendEnabled(SEND_WHYNTER);  printDecodeEnabled(DECODE_WHYNTER);
+  Serial.print(F("AIWA_RC_T501: "));  printSendEnabled(SEND_AIWA_RC_T501);  printDecodeEnabled(DECODE_AIWA_RC_T501);
+  Serial.print(F("LG:           "));  printSendEnabled(SEND_LG);  printDecodeEnabled(DECODE_LG);
+  Serial.print(F("SANYO:        "));  printSendEnabled(SEND_SANYO);  printDecodeEnabled(DECODE_SANYO);
+  Serial.print(F("MITSUBISHI:   "));  printSendEnabled(SEND_MITSUBISHI);  printDecodeEnabled(DECODE_MITSUBISHI);
+  Serial.print(F("DISH:         "));  printSendEnabled(SEND_DISH);  printDecodeEnabled(DECODE_DISH);
+  Serial.print(F("SHARP:        "));  printSendEnabled(SEND_SHARP);  printDecodeEnabled(DECODE_SHARP);
+  Serial.print(F("DENON:        "));  printSendEnabled(SEND_DENON);  printDecodeEnabled(DECODE_DENON);
+  Serial.print(F("PRONTO:       "));  printSendEnabled(SEND_PRONTO);  Serial.println(F("(Not Applicable)"));
+}
+
+void printSendEnabled(int flag) {
+  if (flag) {
+    Serial.print(F("Enabled  "));
+  }
+  else {
+    Serial.print(F("Disabled "));
+  }
+}
+
+void printDecodeEnabled(int flag) {
+  if (flag) {
+    Serial.println(F("Enabled"));
+  }
+  else {
+    Serial.println(F("Disabled"));
+  }
+}
+
+void dumpHeader() {
+  Serial.println(F("IRremoteInfo - by AnalysIR (http://www.AnalysIR.com/)"));
+  Serial.println(F("             - A helper sketch to assist in troubleshooting issues with the library by reviewing the settings within the IRremote library"));
+  Serial.println(F("             - Prints out the important settings within the library, which can be configured to suit the many supported platforms"));
+  Serial.println(F("             - When seeking on-line support, please post or upload the output of this sketch, where appropriate"));
+  Serial.println();
+  Serial.println(F("IRremote Library Settings"));
+  Serial.println(F("========================="));
+}
+
+void dumpFooter() {
+  Serial.println();
+  Serial.println(F("Notes: "));
+  Serial.println(F("     - Most of the seetings above can be configured in the following files included as part of the library"));
+  Serial.println(F("     - IRremteInt.h"));
+  Serial.println(F("     - IRremote.h"));
+  Serial.println(F("     - You can save SRAM by disabling the Decode or Send features for any protocol (Near the top of IRremoteInt.h)"));
+  Serial.println(F("     - Some Timer conflicts, with other libraries, can be easily resolved by configuring a differnt Timer for your platform"));
+}

examples/IRsendDemo/IRsendDemo.ino

@@ -6,20 +6,19 @@
  * http://arcfn.com
  */
 
+
 #include <IRremote.h>
 
 IRsend irsend;
 
 void setup()
 {
-  Serial.begin(9600);
 }
 
 void loop() {
-  if (Serial.read() != -1) {
-    for (int i = 0; i < 3; i++) {
-      irsend.sendSony(0xa90, 12); // Sony TV power code
-      delay(40);
-    }
-  }
+	for (int i = 0; i < 3; i++) {
+		irsend.sendSony(0xa90, 12);
+		delay(40);
+	}
+	delay(5000); //5 second delay between each signal burst
 }

examples/IRsendRawDemo/IRsendRawDemo.ino

@@ -0,0 +1,37 @@
+/*
+ * IRremote: IRsendRawDemo - demonstrates sending IR codes with sendRaw
+ * An IR LED must be connected to Arduino PWM pin 3.
+ * Version 0.1 July, 2009
+ * Copyright 2009 Ken Shirriff
+ * http://arcfn.com
+ *
+ * IRsendRawDemo - added by AnalysIR (via www.AnalysIR.com), 24 August 2015
+ *
+ * This example shows how to send a RAW signal using the IRremote library.
+ * The example signal is actually a 32 bit NEC signal.
+ * Remote Control button: LGTV Power On/Off. 
+ * Hex Value: 0x20DF10EF, 32 bits
+ * 
+ * It is more efficient to use the sendNEC function to send NEC signals. 
+ * Use of sendRaw here, serves only as an example of using the function.
+ * 
+ */
+
+
+#include <IRremote.h>
+
+IRsend irsend;
+
+void setup()
+{
+
+}
+
+void loop() {
+  int khz = 38; // 38kHz carrier frequency for the NEC protocol
+  unsigned int irSignal[] = {9000, 4500, 560, 560, 560, 560, 560, 1690, 560, 560, 560, 560, 560, 560, 560, 560, 560, 560, 560, 1690, 560, 1690, 560, 560, 560, 1690, 560, 1690, 560, 1690, 560, 1690, 560, 1690, 560, 560, 560, 560, 560, 560, 560, 1690, 560, 560, 560, 560, 560, 560, 560, 560, 560, 1690, 560, 1690, 560, 1690, 560, 560, 560, 1690, 560, 1690, 560, 1690, 560, 1690, 560, 39416, 9000, 2210, 560}; //AnalysIR Batch Export (IRremote) - RAW
+  
+  irsend.sendRaw(irSignal, sizeof(irSignal) / sizeof(irSignal[0]), khz); //Note the approach used to automatically calculate the size of the array.
+
+  delay(5000); //In this example, the signal will be repeated every 5 seconds, approximately.
+}

examples/LGACSendDemo/LGACSendDemo.ino

@@ -0,0 +1,263 @@
+#include <IRremote.h>
+#include <Wire.h>
+
+
+IRsend irsend;
+// not used
+int RECV_PIN = 11;
+IRrecv irrecv (RECV_PIN);
+
+const int AC_TYPE  = 0;
+// 0 : TOWER
+// 1 : WALL
+//
+
+int AC_HEAT = 0;
+// 0 : cooling
+// 1 : heating
+
+int AC_POWER_ON    = 0;
+// 0 : off
+// 1 : on
+
+int AC_AIR_ACLEAN  = 0;
+// 0 : off
+// 1 : on --> power on
+
+int AC_TEMPERATURE = 27;
+// temperature : 18 ~ 30
+
+int AC_FLOW        = 1;
+// 0 : low
+// 1 : mid
+// 2 : high
+// if AC_TYPE =1, 3 : change
+//
+
+
+const int AC_FLOW_TOWER[3] = {0, 4, 6};
+const int AC_FLOW_WALL[4]  = {0, 2, 4, 5};
+
+unsigned long AC_CODE_TO_SEND;
+
+int r = LOW;
+int o_r = LOW;
+
+byte a, b;
+
+void ac_send_code(unsigned long code)
+{
+  Serial.print("code to send : ");
+  Serial.print(code, BIN);
+  Serial.print(" : ");
+  Serial.println(code, HEX);
+
+  irsend.sendLG(code, 28);
+}
+
+void ac_activate(int temperature, int air_flow)
+{
+
+  int AC_MSBITS1 = 8;
+  int AC_MSBITS2 = 8;
+  int AC_MSBITS3 = 0;
+  int AC_MSBITS4 ;
+  if ( AC_HEAT == 1 ) {
+    // heating
+    AC_MSBITS4 = 4;
+  } else {
+    // cooling
+    AC_MSBITS4 = 0;
+  }
+  int AC_MSBITS5 = temperature - 15;
+  int AC_MSBITS6 ;
+
+  if ( AC_TYPE == 0) {
+    AC_MSBITS6 = AC_FLOW_TOWER[air_flow];
+  } else {
+    AC_MSBITS6 = AC_FLOW_WALL[air_flow];
+  }
+
+  int AC_MSBITS7 = (AC_MSBITS3 + AC_MSBITS4 + AC_MSBITS5 + AC_MSBITS6) & B00001111;
+
+  AC_CODE_TO_SEND =  AC_MSBITS1 << 4 ;
+  AC_CODE_TO_SEND =  (AC_CODE_TO_SEND + AC_MSBITS2) << 4;
+  AC_CODE_TO_SEND =  (AC_CODE_TO_SEND + AC_MSBITS3) << 4;
+  AC_CODE_TO_SEND =  (AC_CODE_TO_SEND + AC_MSBITS4) << 4;
+  AC_CODE_TO_SEND =  (AC_CODE_TO_SEND + AC_MSBITS5) << 4;
+  AC_CODE_TO_SEND =  (AC_CODE_TO_SEND + AC_MSBITS6) << 4;
+  AC_CODE_TO_SEND =  (AC_CODE_TO_SEND + AC_MSBITS7);
+
+  ac_send_code(AC_CODE_TO_SEND);
+
+  AC_POWER_ON = 1;
+  AC_TEMPERATURE = temperature;
+  AC_FLOW = air_flow;
+}
+
+void ac_change_air_swing(int air_swing)
+{
+  if ( AC_TYPE == 0) {
+    if ( air_swing == 1) {
+      AC_CODE_TO_SEND = 0x881316B;
+    } else {
+      AC_CODE_TO_SEND = 0x881317C;
+    }
+  } else {
+    if ( air_swing == 1) {
+      AC_CODE_TO_SEND = 0x8813149;
+    } else {
+      AC_CODE_TO_SEND = 0x881315A;
+    }
+  }
+
+  ac_send_code(AC_CODE_TO_SEND);
+}
+
+void ac_power_down()
+{
+  AC_CODE_TO_SEND = 0x88C0051;
+
+  ac_send_code(AC_CODE_TO_SEND);
+
+  AC_POWER_ON = 0;
+}
+
+void ac_air_clean(int air_clean)
+{
+  if ( air_clean == 1) {
+    AC_CODE_TO_SEND = 0x88C000C;
+  } else {
+    AC_CODE_TO_SEND = 0x88C0084;
+  }
+
+  ac_send_code(AC_CODE_TO_SEND);
+
+  AC_AIR_ACLEAN = air_clean;
+}
+
+void setup()
+{
+  Serial.begin(38400);
+  delay(1000);
+  Wire.begin(7);
+  Wire.onReceive(receiveEvent);
+
+  Serial.println("  - - - T E S T - - -   ");
+
+  /* test
+    ac_activate(25, 1);
+    delay(5000);
+    ac_activate(27, 2);
+    delay(5000);
+
+  */
+}
+
+void loop()
+{
+
+
+  ac_activate(25, 1);
+  delay(5000);
+  ac_activate(27, 0);
+  delay(5000);
+
+
+  if ( r != o_r) {
+
+    /*
+    # a : mode or temp    b : air_flow, temp, swing, clean, cooling/heating
+    # 18 ~ 30 : temp      0 ~ 2 : flow // on
+    # 0 : off             0
+    # 1 : on              0
+    # 2 : air_swing       0 or 1
+    # 3 : air_clean       0 or 1
+    # 4 : air_flow        0 ~ 2 : flow
+    # 5 : temp            18 ~ 30
+    # + : temp + 1
+    # - : temp - 1
+    # m : change cooling to air clean, air clean to cooling
+    */
+    Serial.print("a : ");
+    Serial.print(a);
+    Serial.print("  b : ");
+    Serial.println(b);
+
+    switch (a) {
+      case 0: // off
+        ac_power_down();
+        break;
+      case 1: // on
+        ac_activate(AC_TEMPERATURE, AC_FLOW);
+        break;
+      case 2:
+        if ( b == 0 | b == 1 ) {
+          ac_change_air_swing(b);
+        }
+        break;
+      case 3: // 1  : clean on, power on
+        if ( b == 0 | b == 1 ) {
+          ac_air_clean(b);
+        }
+        break;
+      case 4:
+        if ( 0 <= b && b <= 2  ) {
+          ac_activate(AC_TEMPERATURE, b);
+        }
+        break;
+      case 5:
+        if (18 <= b && b <= 30  ) {
+          ac_activate(b, AC_FLOW);
+        }
+        break;
+      case '+':
+        if ( 18 <= AC_TEMPERATURE && AC_TEMPERATURE <= 29 ) {
+          ac_activate((AC_TEMPERATURE + 1), AC_FLOW);
+        }
+        break;
+      case '-':
+        if ( 19 <= AC_TEMPERATURE && AC_TEMPERATURE <= 30 ) {
+          ac_activate((AC_TEMPERATURE - 1), AC_FLOW);
+        }
+        break;
+      case 'm':
+        /*
+          if ac is on,  1) turn off, 2) turn on ac_air_clean(1)
+          if ac is off, 1) turn on,  2) turn off ac_air_clean(0)
+        */
+        if ( AC_POWER_ON == 1 ) {
+          ac_power_down();
+          delay(100);
+          ac_air_clean(1);
+        } else {
+          if ( AC_AIR_ACLEAN == 1) {
+            ac_air_clean(0);
+            delay(100);
+          }
+          ac_activate(AC_TEMPERATURE, AC_FLOW);
+        }
+        break;
+      default:
+        if ( 18 <= a && a <= 30 ) {
+          if ( 0 <= b && b <= 2 ) {
+            ac_activate(a, b);
+          }
+        }
+    }
+
+    o_r = r ;
+  }
+  delay(100);
+}
+
+
+
+void receiveEvent(int howMany)
+{
+  a = Wire.read();
+  b = Wire.read();
+  r = !r ;
+}
+
+

examples/LGACSendDemo/LGACSendDemo.md

@@ -0,0 +1,93 @@
+=== decoding for LG A/C ====
+- 1) remote of LG AC has two type of HDR mark/space, 8000/4000 and 3100/10000 
+- 2) HDR 8000/4000 is decoded using decodeLG(IRrecvDumpV2) without problem
+- 3) for HDR 3100/10000, use AnalysIR's code : http://www.analysir.com/blog/2014/03/19/air-conditioners-problems-recording-long-infrared-remote-control-signals-arduino/
+- 4) for bin output based on AnalysIR's code : https://gist.github.com/chaeplin/a3a4b4b6b887c663bfe8
+- 5) remove first two byte(11)
+- 6) sample rawcode with bin output : https://gist.github.com/chaeplin/134d232e0b8cfb898860
+
+
+=== *** ===
+- 1) Sample raw code : https://gist.github.com/chaeplin/ab2a7ad1533c41260f0d
+- 2) send raw code : https://gist.github.com/chaeplin/7c800d3166463bb51be4
+
+
+=== *** ===
+- (0) : Cooling or Heating
+- (1) : fixed 
+- (2) : fixed
+- (3) : special(power, swing, air clean)
+- (4) : change air flow, temperature, cooling(0)/heating(4)
+- (5) : temperature ( 15 + (5) = )
+- (6) : air flow
+- (7) : crc ( 3 + 4 + 5 + 6 ) & B00001111
+
+
+°F = °C × 1.8 + 32
+°C = (°F − 32) / 1.8
+
+
+=== *** ===
+* remote / Korea / without heating
+
+|       status   |(0)| (1)| (2)| (3)| (4)| (5)| (6)| (7)
+|----------------|---|----|----|----|----|----|----|----
+| on / 25 / mid  | C |1000|1000|0000|0000|1010|0010|1100
+| on / 26 / mid  | C |1000|1000|0000|0000|1011|0010|1101      
+| on / 27 / mid  | C |1000|1000|0000|0000|1100|0010|1110     
+| on / 28 / mid  | C |1000|1000|0000|0000|1101|0010|1111     
+| on / 25 / high | C |1000|1000|0000|0000|1010|0100|1110     
+| on / 26 / high | C |1000|1000|0000|0000|1011|0100|1111     
+| on / 27 / high | C |1000|1000|0000|0000|1100|0100|0000     
+| on / 28 / high | C |1000|1000|0000|0000|1101|0100|0001
+|----------------|---|----|----|----|----|----|----|----    
+| 1 up           | C |1000|1000|0000|1000|1101|0100|1001 
+|----------------|---|----|----|----|----|----|----|----    
+| Cool power     | C |1000|1000|0001|0000|0000|1100|1101     
+| energy saving  | C |1000|1000|0001|0000|0000|0100|0101     
+| power          | C |1000|1000|0001|0000|0000|1000|1001            
+| flow/up/down   | C |1000|1000|0001|0011|0001|0100|1001     
+| up/down off    | C |1000|1000|0001|0011|0001|0101|1010     
+| flow/left/right| C |1000|1000|0001|0011|0001|0110|1011     
+| left/right off | C |1000|1000|0001|0011|0001|0111|1100 
+|----------------|---|----|----|----|----|----|----|----    
+| Air clean      | C |1000|1000|1100|0000|0000|0000|1100
+|----------------|---|----|----|----|----|----|----|----    
+| off            | C |1000|1000|1100|0000|0000|0101|0001 
+
+
+
+* remote / with heating 
+* converted using raw code at https://github.com/chaeplin/RaspAC/blob/master/lircd.conf 
+
+|       status   |(0)| (1)| (2)| (3)| (4)| (5)| (6)| (7)
+|----------------|---|----|----|----|----|----|----|----
+| on             | C |1000|1000|0000|0000|1011|0010|1101
+|----------------|---|----|----|----|----|----|----|----
+| off            | C |1000|1000|1100|0000|0000|0101|0001
+|----------------|---|----|----|----|----|----|----|----
+| 64  / 18       | C |1000|1000|0000|0000|0011|0100|0111
+| 66  / 19       | C |1000|1000|0000|0000|0100|0100|1000
+| 68  / 20       | C |1000|1000|0000|0000|0101|0100|1001
+| 70  / 21       | C |1000|1000|0000|0000|0110|0100|1010
+| 72  / 22       | C |1000|1000|0000|0000|0111|0100|1011
+| 74  / 23       | C |1000|1000|0000|0000|1000|0100|1100
+| 76  / 25       | C |1000|1000|0000|0000|1010|0100|1110
+| 78  / 26       | C |1000|1000|0000|0000|1011|0100|1111
+| 80  / 27       | C |1000|1000|0000|0000|1100|0100|0000
+| 82  / 28       | C |1000|1000|0000|0000|1101|0100|0001
+| 84  / 29       | C |1000|1000|0000|0000|1110|0100|0010
+| 86  / 30       | C |1000|1000|0000|0000|1111|0100|0011
+|----------------|---|----|----|----|----|----|----|----
+| heat64         | H |1000|1000|0000|0100|0011|0100|1011
+| heat66         | H |1000|1000|0000|0100|0100|0100|1100
+| heat68         | H |1000|1000|0000|0100|0101|0100|1101
+| heat70         | H |1000|1000|0000|0100|0110|0100|1110
+| heat72         | H |1000|1000|0000|0100|0111|0100|1111
+| heat74         | H |1000|1000|0000|0100|1000|0100|0000
+| heat76         | H |1000|1000|0000|0100|1001|0100|0001
+| heat78         | H |1000|1000|0000|0100|1011|0100|0011
+| heat80         | H |1000|1000|0000|0100|1100|0100|0100
+| heat82         | H |1000|1000|0000|0100|1101|0100|0101
+| heat84         | H |1000|1000|0000|0100|1110|0100|0110
+| heat86         | H |1000|1000|0000|0100|1111|0100|0111

examples/LegoPowerFunctionsSendDemo/LegoPowerFunctionsSendDemo.ino

@@ -0,0 +1,22 @@
+/*
+ * LegoPowerFunctionsSendDemo: LEGO Power Functions
+ * Copyright (c) 2016 Philipp Henkel
+ */
+
+#include <IRremote.h>
+#include <IRremoteInt.h>
+
+IRsend irsend;
+
+void setup() {
+}
+
+void loop() {
+  // Send repeated command "channel 1, blue forward, red backward"
+  irsend.sendLegoPowerFunctions(0x197);
+  delay(2000);
+
+  // Send single command "channel 1, blue forward, red backward"
+  irsend.sendLegoPowerFunctions(0x197, false);
+  delay(2000);
+}

examples/LegoPowerFunctionsTests/LegoPowerFunctionsTests.ino

@@ -0,0 +1,197 @@
+/*
+ * LegoPowerFunctionsTest: LEGO Power Functions Tests
+ * Copyright (c) 2016 Philipp Henkel
+ */
+
+#include <ir_Lego_PF_BitStreamEncoder.h>
+
+void setup() {
+  Serial.begin(9600);
+  delay(1000); // wait for reset triggered by serial connection
+  runBitStreamEncoderTests();
+}
+
+void loop() {
+}
+
+void runBitStreamEncoderTests() {
+  Serial.println();
+  Serial.println("BitStreamEncoder Tests");
+  static LegoPfBitStreamEncoder bitStreamEncoder;
+  testStartBit(bitStreamEncoder);
+  testLowBit(bitStreamEncoder);
+  testHighBit(bitStreamEncoder);
+  testMessageBitCount(bitStreamEncoder);
+  testMessageBitCountRepeat(bitStreamEncoder);
+  testMessage407(bitStreamEncoder);
+  testMessage407Repeated(bitStreamEncoder);
+  testGetChannelId1(bitStreamEncoder);
+  testGetChannelId2(bitStreamEncoder);
+  testGetChannelId3(bitStreamEncoder);
+  testGetChannelId4(bitStreamEncoder);
+  testGetMessageLengthAllHigh(bitStreamEncoder);
+  testGetMessageLengthAllLow(bitStreamEncoder);
+}
+
+void logTestResult(bool testPassed) {
+  if (testPassed) {
+    Serial.println("OK");
+  }
+  else {
+    Serial.println("FAIL  ############");
+  }
+}
+
+void testStartBit(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testStartBit                    ");
+  bitStreamEncoder.reset(0, false);
+  int startMark = bitStreamEncoder.getMarkDuration();
+  int startPause = bitStreamEncoder.getPauseDuration();
+  logTestResult(startMark == 158 && startPause == 1184-158);
+}
+
+void testLowBit(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testLowBit                      ");
+  bitStreamEncoder.reset(0, false);
+  bitStreamEncoder.next();
+  int lowMark = bitStreamEncoder.getMarkDuration();
+  int lowPause = bitStreamEncoder.getPauseDuration();
+  logTestResult(lowMark == 158 && lowPause == 421-158);
+}
+
+void testHighBit(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testHighBit                     ");
+  bitStreamEncoder.reset(0xFFFF, false);
+  bitStreamEncoder.next();
+  int highMark = bitStreamEncoder.getMarkDuration();
+  int highPause = bitStreamEncoder.getPauseDuration();
+  logTestResult(highMark == 158 && highPause == 711-158);
+}
+
+void testMessageBitCount(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testMessageBitCount             ");
+  bitStreamEncoder.reset(0xFFFF, false);
+  int bitCount = 1;
+  while (bitStreamEncoder.next()) {
+    bitCount++;
+  }
+  logTestResult(bitCount == 18);
+}
+
+boolean check(LegoPfBitStreamEncoder& bitStreamEncoder, int markDuration, int pauseDuration) {
+  bool result = true;
+  result = result && bitStreamEncoder.getMarkDuration() == markDuration;
+  result = result && bitStreamEncoder.getPauseDuration() == pauseDuration;
+  return result;
+}
+
+boolean checkNext(LegoPfBitStreamEncoder& bitStreamEncoder, int markDuration, int pauseDuration) {
+  bool result = bitStreamEncoder.next();
+  result = result && check(bitStreamEncoder, markDuration, pauseDuration);
+  return result;
+}
+
+boolean checkDataBitsOfMessage407(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  bool result = true;
+  result = result && checkNext(bitStreamEncoder, 158, 263);
+  result = result && checkNext(bitStreamEncoder, 158, 263);
+  result = result && checkNext(bitStreamEncoder, 158, 263);
+  result = result && checkNext(bitStreamEncoder, 158, 263);
+  result = result && checkNext(bitStreamEncoder, 158, 263);
+  result = result && checkNext(bitStreamEncoder, 158, 263);
+  result = result && checkNext(bitStreamEncoder, 158, 263);
+  result = result && checkNext(bitStreamEncoder, 158, 553);
+  result = result && checkNext(bitStreamEncoder, 158, 553);
+  result = result && checkNext(bitStreamEncoder, 158, 263);
+  result = result && checkNext(bitStreamEncoder, 158, 263);
+  result = result && checkNext(bitStreamEncoder, 158, 553);
+  result = result && checkNext(bitStreamEncoder, 158, 263);
+  result = result && checkNext(bitStreamEncoder, 158, 553);
+  result = result && checkNext(bitStreamEncoder, 158, 553);
+  result = result && checkNext(bitStreamEncoder, 158, 553);
+  return result;
+}
+
+void testMessage407(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testMessage407                  ");
+  bitStreamEncoder.reset(407, false);
+  bool result = true;
+  result = result && check(bitStreamEncoder, 158, 1026);
+  result = result && checkDataBitsOfMessage407(bitStreamEncoder);
+  result = result && checkNext(bitStreamEncoder, 158, 1026);
+  result = result && !bitStreamEncoder.next();
+  logTestResult(result);
+}
+
+void testMessage407Repeated(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testMessage407Repeated          ");
+  bitStreamEncoder.reset(407, true);
+  bool result = true;
+  result = result && check(bitStreamEncoder, 158, 1026);
+  result = result && checkDataBitsOfMessage407(bitStreamEncoder);
+  result = result && checkNext(bitStreamEncoder, 158, 1026 + 5 * 16000 - 10844);
+  result = result && checkNext(bitStreamEncoder, 158, 1026);
+  result = result && checkDataBitsOfMessage407(bitStreamEncoder);
+  result = result && checkNext(bitStreamEncoder, 158, 1026 + 5 * 16000 - 10844);
+  result = result && checkNext(bitStreamEncoder, 158, 1026);
+  result = result && checkDataBitsOfMessage407(bitStreamEncoder);
+  result = result && checkNext(bitStreamEncoder, 158, 1026 + 8 * 16000 - 10844);
+  result = result && checkNext(bitStreamEncoder, 158, 1026);
+  result = result && checkDataBitsOfMessage407(bitStreamEncoder);
+  result = result && checkNext(bitStreamEncoder, 158, 1026 + 8 * 16000 - 10844);
+  result = result && checkNext(bitStreamEncoder, 158, 1026);
+  result = result && checkDataBitsOfMessage407(bitStreamEncoder);
+  result = result && checkNext(bitStreamEncoder, 158, 1026);
+  result = result && !bitStreamEncoder.next();
+  logTestResult(result);
+}
+
+void testMessageBitCountRepeat(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testMessageBitCountRepeat       ");
+  bitStreamEncoder.reset(0xFFFF, true);
+  int bitCount = 1;
+  while (bitStreamEncoder.next()) {
+    bitCount++;
+  }
+  logTestResult(bitCount == 5*18);
+}
+
+void testGetChannelId1(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testGetChannelId1               ");
+  bitStreamEncoder.reset(407, false);
+  logTestResult(bitStreamEncoder.getChannelId() == 1);
+}
+
+void testGetChannelId2(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testGetChannelId2               ");
+  bitStreamEncoder.reset(4502, false);
+  logTestResult(bitStreamEncoder.getChannelId() == 2);
+}
+
+void testGetChannelId3(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testGetChannelId3               ");
+  bitStreamEncoder.reset(8597, false);
+  logTestResult(bitStreamEncoder.getChannelId() == 3);
+}
+
+void testGetChannelId4(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testGetChannelId4               ");
+  bitStreamEncoder.reset(12692, false);
+  logTestResult(bitStreamEncoder.getChannelId() == 4);
+}
+
+void testGetMessageLengthAllHigh(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testGetMessageLengthAllHigh     ");
+  bitStreamEncoder.reset(0xFFFF, false);
+  logTestResult(bitStreamEncoder.getMessageLength() == 13744);
+}
+
+void testGetMessageLengthAllLow(LegoPfBitStreamEncoder& bitStreamEncoder) {
+  Serial.print("  testGetMessageLengthAllLow      ");
+  bitStreamEncoder.reset(0x0, false);
+  logTestResult(bitStreamEncoder.getMessageLength() == 9104);
+}
+
+
+
+

irRecv.cpp

@@ -0,0 +1,218 @@
+#include "IRremote.h"
+#include "IRremoteInt.h"
+
+//+=============================================================================
+// Decodes the received IR message
+// Returns 0 if no data ready, 1 if data ready.
+// Results of decoding are stored in results
+//
+int  IRrecv::decode (decode_results *results)
+{
+	results->rawbuf   = irparams.rawbuf;
+	results->rawlen   = irparams.rawlen;
+
+	results->overflow = irparams.overflow;
+
+	if (irparams.rcvstate != STATE_STOP)  return false ;
+
+#if DECODE_NEC
+	DBG_PRINTLN("Attempting NEC decode");
+	if (decodeNEC(results))  return true ;
+#endif
+
+#if DECODE_SONY
+	DBG_PRINTLN("Attempting Sony decode");
+	if (decodeSony(results))  return true ;
+#endif
+
+#if DECODE_SANYO
+	DBG_PRINTLN("Attempting Sanyo decode");
+	if (decodeSanyo(results))  return true ;
+#endif
+
+#if DECODE_MITSUBISHI
+	DBG_PRINTLN("Attempting Mitsubishi decode");
+	if (decodeMitsubishi(results))  return true ;
+#endif
+
+#if DECODE_RC5
+	DBG_PRINTLN("Attempting RC5 decode");
+	if (decodeRC5(results))  return true ;
+#endif
+
+#if DECODE_RC6
+	DBG_PRINTLN("Attempting RC6 decode");
+	if (decodeRC6(results))  return true ;
+#endif
+
+#if DECODE_PANASONIC
+	DBG_PRINTLN("Attempting Panasonic decode");
+	if (decodePanasonic(results))  return true ;
+#endif
+
+#if DECODE_LG
+	DBG_PRINTLN("Attempting LG decode");
+	if (decodeLG(results))  return true ;
+#endif
+
+#if DECODE_JVC
+	DBG_PRINTLN("Attempting JVC decode");
+	if (decodeJVC(results))  return true ;
+#endif
+
+#if DECODE_SAMSUNG
+	DBG_PRINTLN("Attempting SAMSUNG decode");
+	if (decodeSAMSUNG(results))  return true ;
+#endif
+
+#if DECODE_WHYNTER
+	DBG_PRINTLN("Attempting Whynter decode");
+	if (decodeWhynter(results))  return true ;
+#endif
+
+#if DECODE_AIWA_RC_T501
+	DBG_PRINTLN("Attempting Aiwa RC-T501 decode");
+	if (decodeAiwaRCT501(results))  return true ;
+#endif
+
+#if DECODE_DENON
+	DBG_PRINTLN("Attempting Denon decode");
+	if (decodeDenon(results))  return true ;
+#endif
+
+#if DECODE_LEGO_PF
+	DBG_PRINTLN("Attempting Lego Power Functions");
+	if (decodeLegoPowerFunctions(results))  return true ;
+#endif
+
+	// decodeHash returns a hash on any input.
+	// Thus, it needs to be last in the list.
+	// If you add any decodes, add them before this.
+	if (decodeHash(results))  return true ;
+
+	// Throw away and start over
+	resume();
+	return false;
+}
+
+//+=============================================================================
+IRrecv::IRrecv (int recvpin)
+{
+	irparams.recvpin = recvpin;
+	irparams.blinkflag = 0;
+}
+
+IRrecv::IRrecv (int recvpin, int blinkpin)
+{
+	irparams.recvpin = recvpin;
+	irparams.blinkpin = blinkpin;
+	pinMode(blinkpin, OUTPUT);
+	irparams.blinkflag = 0;
+}
+
+
+
+//+=============================================================================
+// initialization
+//
+void  IRrecv::enableIRIn ( )
+{
+	cli();
+	// Setup pulse clock timer interrupt
+	// Prescale /8 (16M/8 = 0.5 microseconds per tick)
+	// Therefore, the timer interval can range from 0.5 to 128 microseconds
+	// Depending on the reset value (255 to 0)
+	TIMER_CONFIG_NORMAL();
+
+	// Timer2 Overflow Interrupt Enable
+	TIMER_ENABLE_INTR;
+
+	TIMER_RESET;
+
+	sei();  // enable interrupts
+
+	// Initialize state machine variables
+	irparams.rcvstate = STATE_IDLE;
+	irparams.rawlen = 0;
+
+	// Set pin modes
+	pinMode(irparams.recvpin, INPUT);
+}
+
+//+=============================================================================
+// Enable/disable blinking of pin 13 on IR processing
+//
+void  IRrecv::blink13 (int blinkflag)
+{
+	irparams.blinkflag = blinkflag;
+	if (blinkflag)  pinMode(BLINKLED, OUTPUT) ;
+}
+
+//+=============================================================================
+// Return if receiving new IR signals
+//
+bool  IRrecv::isIdle ( )
+{
+ return (irparams.rcvstate == STATE_IDLE || irparams.rcvstate == STATE_STOP) ? true : false;
+}
+//+=============================================================================
+// Restart the ISR state machine
+//
+void  IRrecv::resume ( )
+{
+	irparams.rcvstate = STATE_IDLE;
+	irparams.rawlen = 0;
+}
+
+//+=============================================================================
+// hashdecode - decode an arbitrary IR code.
+// Instead of decoding using a standard encoding scheme
+// (e.g. Sony, NEC, RC5), the code is hashed to a 32-bit value.
+//
+// The algorithm: look at the sequence of MARK signals, and see if each one
+// is shorter (0), the same length (1), or longer (2) than the previous.
+// Do the same with the SPACE signals.  Hash the resulting sequence of 0's,
+// 1's, and 2's to a 32-bit value.  This will give a unique value for each
+// different code (probably), for most code systems.
+//
+// http://arcfn.com/2010/01/using-arbitrary-remotes-with-arduino.html
+//
+// Compare two tick values, returning 0 if newval is shorter,
+// 1 if newval is equal, and 2 if newval is longer
+// Use a tolerance of 20%
+//
+int  IRrecv::compare (unsigned int oldval,  unsigned int newval)
+{
+	if      (newval < oldval * .8)  return 0 ;
+	else if (oldval < newval * .8)  return 2 ;
+	else                            return 1 ;
+}
+
+//+=============================================================================
+// Use FNV hash algorithm: http://isthe.com/chongo/tech/comp/fnv/#FNV-param
+// Converts the raw code values into a 32-bit hash code.
+// Hopefully this code is unique for each button.
+// This isn't a "real" decoding, just an arbitrary value.
+//
+#define FNV_PRIME_32 16777619
+#define FNV_BASIS_32 2166136261
+
+long  IRrecv::decodeHash (decode_results *results)
+{
+	long  hash = FNV_BASIS_32;
+
+	// Require at least 6 samples to prevent triggering on noise
+	if (results->rawlen < 6)  return false ;
+
+	for (int i = 1;  (i + 2) < results->rawlen;  i++) {
+		int value =  compare(results->rawbuf[i], results->rawbuf[i+2]);
+		// Add value into the hash
+		hash = (hash * FNV_PRIME_32) ^ value;
+	}
+
+	results->value       = hash;
+	results->bits        = 32;
+	results->decode_type = UNKNOWN;
+
+	return true;
+}

irSend.cpp

@@ -0,0 +1,87 @@
+#include "IRremote.h"
+#include "IRremoteInt.h"
+
+//+=============================================================================
+void  IRsend::sendRaw (const unsigned int buf[],  unsigned int len,  unsigned int hz)
+{
+	// Set IR carrier frequency
+	enableIROut(hz);
+
+	for (unsigned int i = 0;  i < len;  i++) {
+		if (i & 1)  space(buf[i]) ;
+		else        mark (buf[i]) ;
+	}
+
+	space(0);  // Always end with the LED off
+}
+
+//+=============================================================================
+// Sends an IR mark for the specified number of microseconds.
+// The mark output is modulated at the PWM frequency.
+//
+void  IRsend::mark (unsigned int time)
+{
+	TIMER_ENABLE_PWM; // Enable pin 3 PWM output
+	if (time > 0) custom_delay_usec(time);
+}
+
+//+=============================================================================
+// Leave pin off for time (given in microseconds)
+// Sends an IR space for the specified number of microseconds.
+// A space is no output, so the PWM output is disabled.
+//
+void  IRsend::space (unsigned int time)
+{
+	TIMER_DISABLE_PWM; // Disable pin 3 PWM output
+	if (time > 0) IRsend::custom_delay_usec(time);
+}
+
+
+
+
+
+//+=============================================================================
+// Enables IR output.  The khz value controls the modulation frequency in kilohertz.
+// The IR output will be on pin 3 (OC2B).
+// This routine is designed for 36-40KHz; if you use it for other values, it's up to you
+// to make sure it gives reasonable results.  (Watch out for overflow / underflow / rounding.)
+// TIMER2 is used in phase-correct PWM mode, with OCR2A controlling the frequency and OCR2B
+// controlling the duty cycle.
+// There is no prescaling, so the output frequency is 16MHz / (2 * OCR2A)
+// To turn the output on and off, we leave the PWM running, but connect and disconnect the output pin.
+// A few hours staring at the ATmega documentation and this will all make sense.
+// See my Secrets of Arduino PWM at http://arcfn.com/2009/07/secrets-of-arduino-pwm.html for details.
+//
+void  IRsend::enableIROut (int khz)
+{
+	// Disable the Timer2 Interrupt (which is used for receiving IR)
+	TIMER_DISABLE_INTR; //Timer2 Overflow Interrupt
+
+	pinMode(TIMER_PWM_PIN, OUTPUT);
+	digitalWrite(TIMER_PWM_PIN, LOW); // When not sending PWM, we want it low
+
+	// COM2A = 00: disconnect OC2A
+	// COM2B = 00: disconnect OC2B; to send signal set to 10: OC2B non-inverted
+	// WGM2 = 101: phase-correct PWM with OCRA as top
+	// CS2  = 000: no prescaling
+	// The top value for the timer.  The modulation frequency will be SYSCLOCK / 2 / OCR2A.
+	TIMER_CONFIG_KHZ(khz);
+}
+
+//+=============================================================================
+// Custom delay function that circumvents Arduino's delayMicroseconds limit
+
+void IRsend::custom_delay_usec(unsigned long uSecs) {
+  if (uSecs > 4) {
+    unsigned long start = micros();
+    unsigned long endMicros = start + uSecs - 4;
+    if (endMicros < start) { // Check if overflow
+      while ( micros() > start ) {} // wait until overflow
+    }
+    while ( micros() < endMicros ) {} // normal wait
+  } 
+  //else {
+  //  __asm__("nop\n\t"); // must have or compiler optimizes out
+  //}
+}
+

keywords.txt

@@ -31,8 +31,8 @@ sendSharp KEYWORD2
 sendSharpRaw KEYWORD2
 sendPanasonic KEYWORD2
 sendJVC KEYWORD2
+sendLG KEYWORD2
 
-#
 #######################################
 # Constants (LITERAL1)
 #######################################
@@ -48,5 +48,6 @@ SHARP LITERAL1
 PANASONIC LITERAL1
 JVC LITERAL1
 LG LITERAL1
+AIWA_RC_T501 LITERAL1
 UNKNOWN	LITERAL1
 REPEAT	LITERAL1

library.json

@@ -5,8 +5,20 @@
   "repository":
   {
     "type": "git",
-    "url": "https://github.com/shirriff/Arduino-IRremote.git"
+    "url": "https://github.com/z3t0/Arduino-IRremote.git"
   },
+  "version": "2.2.1",
   "frameworks": "arduino",
-  "platforms": "atmelavr"
+  "platforms": "atmelavr",
+  "authors" :
+  [
+     {
+       "name":"Rafi Khan",
+       "email":"zetoslab@gmail.com"
+     },
+     {
+       "name":"Ken Shirriff",
+       "email":"ken.shirriff@gmail.com"
+     }
+  ]
 }

library.properties

@@ -0,0 +1,8 @@
+name=IRremote
+version=3.0.0
+author=shirriff, z3t0 <zetoslab@gmail.com>
+maintainer=z3t0 <zetoslab@gmail.com>
+sentence=Send and receive infrared signals with multiple protocols
+category=Communication
+url=http://z3t0.github.io/Arduino-IRremote/
+architectures=*