From d155e9ab6202686de95466830e08d9498f3f19ec Mon Sep 17 00:00:00 2001 From: ukw Date: Wed, 26 May 2010 09:01:55 +0000 Subject: [PATCH] Version 1.4.0: Added Grundig + Nokia protocol git-svn-id: svn://mikrocontroller.net/irmp@15 aeb2e35e-bfc4-4214-b83c-9e8de998ed28 --- IR-Data/Dbox.txt | 52 +++ IR-Data/Nokia.txt | 1 + IR-Data/test-suite.sh | 14 + README.txt | 4 +- irmp.c | 724 +++++++++++++++++++++++------------------- irmp.exe | Bin 22016 -> 22528 bytes irmp.h | 48 +-- irmpconfig.h | 3 +- irsnd.c | 347 +++++++++++--------- irsnd.exe | Bin 12800 -> 12800 bytes irsndconfig.h | 3 +- 11 files changed, 691 insertions(+), 505 deletions(-) create mode 100644 IR-Data/Dbox.txt create mode 100644 IR-Data/Nokia.txt diff --git a/IR-Data/Dbox.txt b/IR-Data/Dbox.txt new file mode 100644 index 0000000..b4f7199 --- /dev/null +++ b/IR-Data/Dbox.txt @@ -0,0 +1,52 @@ +# Power +00000111111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111000000111100000011110000001111000000111100000011110000001111000000111100000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000001111111111000001111100000000001111100000111111111100000111110000011111000001111100000111110000011111000000000011111000001111100000111111111100000000001111111111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000001111111111111111111111111000001111111111000000000011111000001111100000111110000011111000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111111111111111111111 +# 1 +00000011111111111111111111111100000011111111100000000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000011111000001111100000111110000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111110000011111111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111111111000000000001111000000111100000011110000001111000000111100000011110000001111000000111100000111110000011111000001111100000111110000011111000001111100000111111111111111111111 +# 2 +00000111111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000001111111111000000000011111111110000011111000001111100000111110000011111000001111100000111110000011111000000000011111000001111100000111111111100000000001111111111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000001111111111111111111111111000001111111111000000000011111000001111100000111110000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111111111111111111111 +# 3 +00000111111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111100000011110000001111000000111100000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111100000011110000001111111110000011111000001111100000111110000011111000001111100000111110000011111000000000011111000001111100000111111111100000000001111111111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000001111111111111111111111111000001111111111000000000011111000001111100000111110000011111000001111100000111110000011111000001111100000111100000011110000001111000000111100000011110000001111000000111111111111111111111 +# HOME +0000001111111111111111111111110000001111111110000000000011110000001111000000111100000011110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000011111111111111111111111110000011111111110000011111000001111100000111110000011111000000000011111111110000011110000001111000000111100000000000111100000011110000001111111110000000000011111111100000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000011111111111111111111111100000011111111100000011110000001111000000111100000011110000000000011111111100000011110000001111000000111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111111111111111 +# 4 +000001111111111111111111111111000001111111111000000000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000001111111111111111111111110000001111111110000001111000000000001111111110000001111000000111100000011110000001111000001111100000111110000000000111110000011111000001111111111000000000011111111110000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000001111111111111111111111110000011111111110000011111000000000011111111110000011111000001111100000111110000011111000001111100000111110000000000111110000011111000001111111111000000000011111111110000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111110000011111111110000000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 +# 5 +0000011111111111111111111111110000011111111110000000000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011110000001111000000111100000011110000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000011110000001111111110000000000111111111100000111110000011111000001111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111110000011111111110000000000111111111100000111110000011111000001111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111111111000000000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000001111100000111110000011111000001111100000111111111111111111 +# 6 +0000001111111111111111111111110000001111111110000000000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000111110000011111000001111100000111110000011111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000011111111111111111111111110000011111111110000000000111110000011111111110000011111000001111100000111110000011111000001111100000111110000000000111110000011110000001111111110000000000011111111100000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111110000011111111100000000000111100000011111111100000011110000001111000000111100000011110000001111000000111100000000000111100000011110000001111111110000000000011111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111111111111111 +# EXIT +00000111111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111000000111100000011110000001111000000111100000011110000001111000000111100000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000001111100000111110000011111000001111111111000001111100000000001111111111000001111100000111110000011111000000000011111000001111100000111111111100000000001111111111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000001111111111111111111111111000001111111111000000000011111000001111100000111110000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111111111111111111111 +# 7 +0000011111111111111111111111110000011111111110000000000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011110000001111000000111100000011110000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000011110000001111000000111100000111111111100000111110000011111000001111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111110000011111000001111100000111111111100000111110000011111000001111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111111111000000000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000001111100000111110000011111000001111100000111111111111111111 +# 8 +00000011111111111111111111111110000011111111110000000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111111111100000111110000011111000000000011111111110000011111000001111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111111111000000000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000001111100000111111111111111111111 +# 9 +0000011111111111111111111111100000011111111100000000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000111110000011111000001111100000111110000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111110000011111111110000011111000000000011111111110000011111000001111100000111110000011111000001111100000000001111100000111100000011111111100000000000111111111000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111100000111100000011111111100000011110000000000011111111100000011110000001111000000111100000011110000001111000000000001111000000111100000011111111100000000000111111111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000001111111111000000000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111111111111111111 +# 0 +0000001111111111111111111111110000001111111110000000000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000011111000001111100000111110000011111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000011111111111111111111111110000011111111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000000000111110000011111000001111111110000000000011111111100000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000011111111111111111111111110000011111111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000000000111100000011110000001111111110000000000011111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111111111111111 +# Rot +0000001111111111111111111111110000011111111110000000000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111110000011110000001111111110000000000011110000001111111110000000000011111111100000011110000001111000000111100000000000111100000011110000001111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000011110000001111111110000000000111110000011111111110000000000111111111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111100000111100000011110000001111000000111100000011110000001111000000111100000011111111111111111 +# Grün +00000011111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111100000011111111100000000000111111111000000000001111111110000000000011111111100000011110000001111000000000001111000000111100000111111111100000000001111111111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000001111111111111111111111111000001111111111000000000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111111111111111111111 +# Gelb +00000111111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011110000001111000000111100000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111111111000000000001111111110000001111000000000011111111110000000000111111111100000111110000011111000000000011111000001111100000111111111100000000001111111111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000001111111111111111111111111000001111111111000000000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011110000001111000000111100000011110000001111000000111111111111111111111 +# Blau +00000011111111111111111111111100000011111111100000000000111100000011110000001111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111110000011111000001111111111000000000011111000001111100000111111111000000111100000011110000001111000000000001111000000111100000011111111100000000000111111111000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111111111000000000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111111111111111111111 +# Hoch +0000011111111111111111111111110000011111111110000000000111110000011111000001111100000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000111111111100000000001111100000111110000011111111110000011111000001111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111111111100000000001111100000111110000011111111110000011111000001111100000111110000011111000001111000000000001111000000111100000011111111100000000000111111111000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111111111000000000001111000000111100000011110000001111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111111111111111111 +# Links +00000111111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111100000011110000001111000000111100000011111111100000000000111111111000000111100000011110000011111000000000011111000001111100000111111111100000000001111111111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000001111111111000000000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111111111111111111111 +# OK +0000001111111111111111111111110000001111111110000000000011110000001111000000111100000011110000001111000000111100000011110000001111000001111100000111110000011111000001111100000111110000011111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000011111111111111111111111110000011111111110000011111000001111100000111110000000000111110000011111111110000011111000001111100000111110000000000111100000011110000001111111110000000000011111111100000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000011111111111111111111111100000011111111100000011110000001111000000111100000000000111100000011111111100000011110000001111000000111100000000000111100000011110000001111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111111111111111 +# Rechts +0000011111111111111111111111110000011111111110000000000111110000011111000001111100000111110000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000111111111100000000001111100000111110000011111111110000000000111111111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111111111100000000001111100000111110000011111111110000000000111111111100000111110000011111000001111100000000001111000000111100000011111111100000000000111111111000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111111111000000000001111000000111100000011110000001111000000111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111111111111111111 +# Runter +0000001111111111111111111111110000011111111110000000000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111110000011110000001111000000111100000011110000001111111110000001111000000111100000011110000001111000000111100000000000111100000011110000001111111110000000000011111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000011110000001111000000111100000111110000011111111110000011111000001111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111100000111100000011110000001111000000111100000011110000001111000000111100000011111111111111111 +# Lauter +0000001111111111111111111111110000011111111110000000000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000011111111100000000000111100000011111111100000000000111111111000000111100000011110000001111000000111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000111111111100000000001111100000111111111100000000001111111111000001111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111111111100000000001111100000111110000011111000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011111111111111111 +# Leiser +0000011111111111111111111111110000011111111110000000000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000011110000001111000000111100000011111111100000000000111111111000000111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000111110000011111000001111100000111111111100000000001111111111000001111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111111111100000000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011111111111111111 +# Mute +0000011111111111111111111111110000011111111110000000000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011110000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000011111111100000011110000001111000000000001111111110000000000011111111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000111111111100000111110000011111000000000011111111110000000000111111111100000111110000011111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111100000111111111000000000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000011110000001111000000111100000111111111111111111 +# Info +0000001111111111111111111111110000011111111110000000000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111110000011111111100000000000111111111000000111100000011110000001111000000111100000000000111111111000000111100000000000111100000011110000001111111110000000000011111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000011111111111111111111111100000011111111100000000000111111111000000111100000111110000011111000001111100000000001111111111000001111100000000001111100000111110000011111111110000000000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111111111100000000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111000000111100000011110000001111000000111100000011111111111111111 diff --git a/IR-Data/Nokia.txt b/IR-Data/Nokia.txt new file mode 100644 index 0000000..346559d --- /dev/null +++ b/IR-Data/Nokia.txt @@ -0,0 +1 @@ +0000001111111111111111111111110000001111111110000000000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000111111111111111111111111100000111110000011111111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000000001111100000111110000011111000001111100000111111111100000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000111111111111111111111111000000111111111000000000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111110000011111000001111100000111111111111111111111 diff --git a/IR-Data/test-suite.sh b/IR-Data/test-suite.sh index 5891ae6..f4b192a 100644 --- a/IR-Data/test-suite.sh +++ b/IR-Data/test-suite.sh @@ -1,10 +1,24 @@ #! /bin/sh +#---------------------------------------------------------------------------- +# test suite for IRMP +# +# usage: +# +# ./test-suite.sh +# +# Copyright (c) 2010 Frank Meyer - frank(at)fli4l.de +# +# $Id: test-suite.sh,v 1.6 2010/05/25 14:44:41 fm Exp $ +#---------------------------------------------------------------------------- + for j in \ + Dbox.txt \ DK_Digital.txt \ Grundig_TP715.txt \ Grundig_TP715_SatTV.txt \ Grundig_TP715_Video.txt \ Matsushita.txt \ + Nokia.txt \ Panasonic-Blue-Ray.txt \ RC5-Taste.txt \ Samsung_DVD_Rec_00062C.txt \ diff --git a/README.txt b/README.txt index b6bab6a..ef53ab8 100644 --- a/README.txt +++ b/README.txt @@ -1,8 +1,8 @@ IRMP - Infrared Multi Protocol Decoder -------------------------------------- -Version IRMP: 1.3.1 17.05.2010 -Version IRSND: 1.3.1 17.05.2010 +Version IRMP: 1.4.0 26.05.2010 +Version IRSND: 1.4.0 26.05.2010 Dokumentation: diff --git a/irmp.c b/irmp.c index f4e2ef7..74aa156 100644 --- a/irmp.c +++ b/irmp.c @@ -3,7 +3,7 @@ * * Copyright (c) 2009-2010 Frank Meyer - frank(at)fli4l.de * - * $Id: irmp.c,v 1.25 2010/05/17 10:31:43 fm Exp $ + * $Id: irmp.c,v 1.31 2010/05/26 08:34:30 fm Exp $ * * ATMEGA88 @ 8 MHz * @@ -23,7 +23,8 @@ * NUBERT - Nubert Subwoofer System * B&O - Bang & Olufsen * PANASONIC - Panasonic (older, yet not implemented) - * Grundig - Grundig + * GRUNDIG - Grundig + * NOKIA - Nokia * *--------------------------------------------------------------------------------------------------------------------------------------------------- * @@ -209,14 +210,16 @@ * *--------------------------------------------------------------------------------------------------------------------------------------------------- * - * Grundig + * GRUNDIG * ------- * - * frame: 1 start packet + n info packets + 1 stop packet - * packet: 1 pre bit + 1 start bit + 9 data bits + no stop bit - * data of start packet: 9 x 1 - * data of info packet: 9 command bits - * data of stop packet: 9 x 1 + * packet: 1 start frame + 19,968ms pause + N info frames + 117,76ms pause + 1 stop frame + * frame: 1 pre bit + 1 start bit + 9 data bits + no stop bit + * pause between info frames: 117,76ms + * + * data of start frame: 9 x 1 + * data of info frame: 9 command bits + * data of stop frame: 9 x 1 * * pre bit: start bit data "0": data "1": * ------____________ ------______ ______------ ------______ @@ -224,6 +227,14 @@ * *--------------------------------------------------------------------------------------------------------------------------------------------------- * + * NOKIA: + * ------ + * + * Timing similar to Grundig, but 16 data bits: + * frame: 1 pre bit + 1 start bit + 8 command bits + 8 address bits + no stop bit + * + *--------------------------------------------------------------------------------------------------------------------------------------------------- + * * PANASONIC (older protocol, yet not implemented, see also MATSUSHITA, timing very similar) * ----------------------------------------------------------------------------------------- * @@ -304,9 +315,15 @@ typedef unsigned int16 uint16_t; #include "irmp.h" #include "irmpconfig.h" +#if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1 || IRMP_SUPPORT_NOKIA_PROTOCOL == 1 +#define IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL 1 +#else +#define IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL 0 +#endif + #define IRMP_TIMEOUT_TIME 16500.0e-6 // timeout after 16.5 ms darkness #define IRMP_TIMEOUT_LEN (uint8_t)(F_INTERRUPTS * IRMP_TIMEOUT_TIME + 0.5) -#define IRMP_REPETITION_TIME (uint16_t)(F_INTERRUPTS * 100.0e-3 + 0.5) // autodetect key repetition within 100 msec +#define IRMP_KEY_REPETITION_LEN (uint16_t)(F_INTERRUPTS * 150.0e-3 + 0.5) // autodetect key repetition within 150 msec #define MIN_TOLERANCE_00 1.0 // -0% #define MAX_TOLERANCE_00 1.0 // +0% @@ -403,10 +420,10 @@ typedef unsigned int16 uint16_t; #define RECS80_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1) #define RECS80_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1) -#define RC5_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1) -#define RC5_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1) -#define RC5_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1) -#define RC5_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1) +#define RC5_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1) +#define RC5_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1) +#define RC5_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1) +#define RC5_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1) #define DENON_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1) #define DENON_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1) @@ -475,14 +492,14 @@ typedef unsigned int16 uint16_t; #define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1) #define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1) -#define GRUNDIG_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1) -#define GRUNDIG_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1) -#define GRUNDIG_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1) -#define GRUNDIG_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1) -#define GRUNDIG_PRE_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_PRE_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) + 1) -#define GRUNDIG_PRE_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_PRE_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1) +#define GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1) +#define GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1) +#define GRUNDIG_OR_NOKIA_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1) +#define GRUNDIG_OR_NOKIA_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1) +#define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) + 1) +#define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1) -#define AUTO_REPETITION_LEN (uint16_t)(F_INTERRUPTS * AUTO_REPETITION_TIME + 0.5) // use uint16_t! +#define AUTO_FRAME_REPETITION_LEN (uint16_t)(F_INTERRUPTS * AUTO_FRAME_REPETITION_TIME + 0.5) // use uint16_t! #ifdef DEBUG #define DEBUG_PUTCHAR(a) { if (! silent) { putchar (a); } } @@ -495,28 +512,17 @@ static int time_counter; #endif #if IRMP_LOGGING == 1 -#define irmp_logIsr(x) irmp_logIr((x) ? 1:0) #define UART_BAUD 9600L // calculate real baud rate: #define UBRR_VAL ((F_CPU + UART_BAUD * 8) / (UART_BAUD * 16) - 1) // round #define BAUD_REAL (F_CPU / (16 * (UBRR_VAL + 1))) // real baudrate +#define BAUD_ERROR ((BAUD_REAL * 1000) / UART_BAUD) // error in promille -#ifdef CODEVISION -#if ((BAUD_REAL * 1000) / UART_BAUD - 1000) > 10 -# error Error of baud rate of RS232 UARTx is more than 1%. That is too high! -#endif - -#else // not CODEVISION - -#define BAUD_ERROR ((BAUD_REAL * 1000) / UART_BAUD - 1000) // error in promille - -#if ((BAUD_ERROR > 10) || (-BAUD_ERROR < 10)) +#if ((BAUD_ERROR < 990) || (BAUD_ERROR > 1010)) # error Error of baud rate of RS232 UARTx is more than 1%. That is too high! #endif -#endif // CODEVISION - /*--------------------------------------------------------------------------------------------------------------------------------------------------- * Initialize UART * @details Initializes UART @@ -551,59 +557,62 @@ irmp_uart_putc (unsigned char ch) * Log IR signal *--------------------------------------------------------------------------------------------------------------------------------------------------- */ -#define c_startcycles 2 // min count of zeros before start of logging -#define c_endBits 1000 // log buffer size -#define c_datalen 700 // number of sequenced highbits to detect end + +#define STARTCYCLES 2 // min count of zeros before start of logging +#define ENDBITS 1000 // number of sequenced highbits to detect end +#define DATALEN 700 // log buffer size static void -irmp_logIr (uint8_t val) +irmp_log (uint8_t val) { - static uint8_t s_data[c_datalen]; // logging buffer - static uint16_t s_dataIdx; // number of written bits - static uint8_t s_startcycles; // current number of start-zeros - static uint16_t s_ctr; // counts sequenced highbits - to detect end + static uint8_t buf[DATALEN]; // logging buffer + static uint16_t buf_idx; // number of written bits + static uint8_t startcycles; // current number of start-zeros + static uint16_t cnt; // counts sequenced highbits - to detect end - if ((val == 0) && (s_startcycles < c_startcycles) && !s_dataIdx) // prevent that single random zeros init logging + if (! val && (startcycles < STARTCYCLES) && !buf_idx) // prevent that single random zeros init logging { - ++s_startcycles; + startcycles++; } else { - s_startcycles = 0; + startcycles = 0; - if ( (val == 0) // start or continue logging on "0" - || ((val == 1) && (s_dataIdx != 0))) // "1" cannot init logging + if (! val || (val && buf_idx != 0)) // start or continue logging on "0", "1" cannot init logging { - if (val) - { // set or clear bit in bitarray - s_data[(s_dataIdx / 8)] |= (1<<(s_dataIdx % 8)); - } - else - { - s_data[(s_dataIdx / 8)] &= ~(1<<(s_dataIdx % 8)); - } + if (buf_idx < DATALEN * 8) // index in range? + { // yes + if (val) + { + buf[(buf_idx / 8)] |= (1<<(buf_idx % 8)); // set bit + } + else + { + buf[(buf_idx / 8)] &= ~(1<<(buf_idx % 8)); // reset bit + } - ++s_dataIdx; + buf_idx++; + } if (val) { // if high received then look at log-stop condition - ++s_ctr; + cnt++; - if (s_ctr > c_endBits) - { // if stop condition (200 sequenced ones) meets, output on uart + if (cnt > ENDBITS) + { // if stop condition is true, output on uart uint16_t i; - for (i = 0; i < c_startcycles; ++i) + for (i = 0; i < STARTCYCLES; i++) { irmp_uart_putc ('0'); // the ignored starting zeros } - for (i = 0;i < (s_dataIdx - c_endBits + 20) / 8; ++i) // transform bitset into uart chars + for (i = 0; i < (buf_idx - ENDBITS + 20) / 8; i++) // transform bitset into uart chars { - uint8_t d = s_data[i]; + uint8_t d = buf[i]; uint8_t j; - for (j = 0;j<8;++j) + for (j = 0; j < 8; j++) { irmp_uart_putc ((d & 1) + '0'); d >>= 1; @@ -611,19 +620,19 @@ irmp_logIr (uint8_t val) } irmp_uart_putc ('\n'); - s_dataIdx = 0; + buf_idx = 0; } } else { - s_ctr = 0; + cnt = 0; } } } } #else -#define irmp_logIsr(x) +#define irmp_log(val) #endif typedef struct @@ -650,22 +659,22 @@ typedef struct static PROGMEM IRMP_PARAMETER sircs_param = { - IRMP_SIRCS_PROTOCOL, - SIRCS_1_PULSE_LEN_MIN, - SIRCS_1_PULSE_LEN_MAX, - SIRCS_PAUSE_LEN_MIN, - SIRCS_PAUSE_LEN_MAX, - SIRCS_0_PULSE_LEN_MIN, - SIRCS_0_PULSE_LEN_MAX, - SIRCS_PAUSE_LEN_MIN, - SIRCS_PAUSE_LEN_MAX, - SIRCS_ADDRESS_OFFSET, - SIRCS_ADDRESS_OFFSET + SIRCS_ADDRESS_LEN, - SIRCS_COMMAND_OFFSET, - SIRCS_COMMAND_OFFSET + SIRCS_COMMAND_LEN, - SIRCS_COMPLETE_DATA_LEN, - SIRCS_STOP_BIT, - SIRCS_LSB + IRMP_SIRCS_PROTOCOL, // protocol: ir protocol + SIRCS_1_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + SIRCS_1_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + SIRCS_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + SIRCS_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + SIRCS_0_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0 + SIRCS_0_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0 + SIRCS_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0 + SIRCS_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0 + SIRCS_ADDRESS_OFFSET, // address_offset: address offset + SIRCS_ADDRESS_OFFSET + SIRCS_ADDRESS_LEN, // address_end: end of address + SIRCS_COMMAND_OFFSET, // command_offset: command offset + SIRCS_COMMAND_OFFSET + SIRCS_COMMAND_LEN, // command_end: end of command + SIRCS_COMPLETE_DATA_LEN, // complete_len: complete length of frame + SIRCS_STOP_BIT, // stop_bit: flag: frame has stop bit + SIRCS_LSB // lsb_first: flag: LSB first }; #endif @@ -674,42 +683,42 @@ static PROGMEM IRMP_PARAMETER sircs_param = static PROGMEM IRMP_PARAMETER nec_param = { - IRMP_NEC_PROTOCOL, - NEC_PULSE_LEN_MIN, - NEC_PULSE_LEN_MAX, - NEC_1_PAUSE_LEN_MIN, - NEC_1_PAUSE_LEN_MAX, - NEC_PULSE_LEN_MIN, - NEC_PULSE_LEN_MAX, - NEC_0_PAUSE_LEN_MIN, - NEC_0_PAUSE_LEN_MAX, - NEC_ADDRESS_OFFSET, - NEC_ADDRESS_OFFSET + NEC_ADDRESS_LEN, - NEC_COMMAND_OFFSET, - NEC_COMMAND_OFFSET + NEC_COMMAND_LEN, - NEC_COMPLETE_DATA_LEN, - NEC_STOP_BIT, - NEC_LSB + IRMP_NEC_PROTOCOL, // protocol: ir protocol + NEC_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + NEC_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + NEC_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + NEC_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + NEC_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0 + NEC_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0 + NEC_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0 + NEC_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0 + NEC_ADDRESS_OFFSET, // address_offset: address offset + NEC_ADDRESS_OFFSET + NEC_ADDRESS_LEN, // address_end: end of address + NEC_COMMAND_OFFSET, // command_offset: command offset + NEC_COMMAND_OFFSET + NEC_COMMAND_LEN, // command_end: end of command + NEC_COMPLETE_DATA_LEN, // complete_len: complete length of frame + NEC_STOP_BIT, // stop_bit: flag: frame has stop bit + NEC_LSB // lsb_first: flag: LSB first }; static PROGMEM IRMP_PARAMETER nec_rep_param = { - IRMP_NEC_PROTOCOL, - NEC_PULSE_LEN_MIN, - NEC_PULSE_LEN_MAX, - NEC_1_PAUSE_LEN_MIN, - NEC_1_PAUSE_LEN_MAX, - NEC_PULSE_LEN_MIN, - NEC_PULSE_LEN_MAX, - NEC_0_PAUSE_LEN_MIN, - NEC_0_PAUSE_LEN_MAX, - 0, - 0, - 0, - 0, - 0, - NEC_STOP_BIT, - NEC_LSB + IRMP_NEC_PROTOCOL, // protocol: ir protocol + NEC_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + NEC_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + NEC_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + NEC_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + NEC_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0 + NEC_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0 + NEC_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0 + NEC_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0 + 0, // address_offset: address offset + 0, // address_end: end of address + 0, // command_offset: command offset + 0, // command_end: end of command + 0, // complete_len: complete length of frame + NEC_STOP_BIT, // stop_bit: flag: frame has stop bit + NEC_LSB // lsb_first: flag: LSB first }; #endif @@ -718,22 +727,22 @@ static PROGMEM IRMP_PARAMETER nec_rep_param = static PROGMEM IRMP_PARAMETER samsung_param = { - IRMP_SAMSUNG_PROTOCOL, - SAMSUNG_PULSE_LEN_MIN, - SAMSUNG_PULSE_LEN_MAX, - SAMSUNG_1_PAUSE_LEN_MIN, - SAMSUNG_1_PAUSE_LEN_MAX, - SAMSUNG_PULSE_LEN_MIN, - SAMSUNG_PULSE_LEN_MAX, - SAMSUNG_0_PAUSE_LEN_MIN, - SAMSUNG_0_PAUSE_LEN_MAX, - SAMSUNG_ADDRESS_OFFSET, - SAMSUNG_ADDRESS_OFFSET + SAMSUNG_ADDRESS_LEN, - SAMSUNG_COMMAND_OFFSET, - SAMSUNG_COMMAND_OFFSET + SAMSUNG_COMMAND_LEN, - SAMSUNG_COMPLETE_DATA_LEN, - SAMSUNG_STOP_BIT, - SAMSUNG_LSB + IRMP_SAMSUNG_PROTOCOL, // protocol: ir protocol + SAMSUNG_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + SAMSUNG_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + SAMSUNG_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + SAMSUNG_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + SAMSUNG_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0 + SAMSUNG_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0 + SAMSUNG_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0 + SAMSUNG_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0 + SAMSUNG_ADDRESS_OFFSET, // address_offset: address offset + SAMSUNG_ADDRESS_OFFSET + SAMSUNG_ADDRESS_LEN, // address_end: end of address + SAMSUNG_COMMAND_OFFSET, // command_offset: command offset + SAMSUNG_COMMAND_OFFSET + SAMSUNG_COMMAND_LEN, // command_end: end of command + SAMSUNG_COMPLETE_DATA_LEN, // complete_len: complete length of frame + SAMSUNG_STOP_BIT, // stop_bit: flag: frame has stop bit + SAMSUNG_LSB // lsb_first: flag: LSB first }; #endif @@ -742,22 +751,22 @@ static PROGMEM IRMP_PARAMETER samsung_param = static PROGMEM IRMP_PARAMETER matsushita_param = { - IRMP_MATSUSHITA_PROTOCOL, - MATSUSHITA_PULSE_LEN_MIN, - MATSUSHITA_PULSE_LEN_MAX, - MATSUSHITA_1_PAUSE_LEN_MIN, - MATSUSHITA_1_PAUSE_LEN_MAX, - MATSUSHITA_PULSE_LEN_MIN, - MATSUSHITA_PULSE_LEN_MAX, - MATSUSHITA_0_PAUSE_LEN_MIN, - MATSUSHITA_0_PAUSE_LEN_MAX, - MATSUSHITA_ADDRESS_OFFSET, - MATSUSHITA_ADDRESS_OFFSET + MATSUSHITA_ADDRESS_LEN, - MATSUSHITA_COMMAND_OFFSET, - MATSUSHITA_COMMAND_OFFSET + MATSUSHITA_COMMAND_LEN, - MATSUSHITA_COMPLETE_DATA_LEN, - MATSUSHITA_STOP_BIT, - MATSUSHITA_LSB + IRMP_MATSUSHITA_PROTOCOL, // protocol: ir protocol + MATSUSHITA_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + MATSUSHITA_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + MATSUSHITA_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + MATSUSHITA_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + MATSUSHITA_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0 + MATSUSHITA_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0 + MATSUSHITA_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0 + MATSUSHITA_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0 + MATSUSHITA_ADDRESS_OFFSET, // address_offset: address offset + MATSUSHITA_ADDRESS_OFFSET + MATSUSHITA_ADDRESS_LEN, // address_end: end of address + MATSUSHITA_COMMAND_OFFSET, // command_offset: command offset + MATSUSHITA_COMMAND_OFFSET + MATSUSHITA_COMMAND_LEN, // command_end: end of command + MATSUSHITA_COMPLETE_DATA_LEN, // complete_len: complete length of frame + MATSUSHITA_STOP_BIT, // stop_bit: flag: frame has stop bit + MATSUSHITA_LSB // lsb_first: flag: LSB first }; #endif @@ -766,22 +775,22 @@ static PROGMEM IRMP_PARAMETER matsushita_param = static PROGMEM IRMP_PARAMETER kaseikyo_param = { - IRMP_KASEIKYO_PROTOCOL, - KASEIKYO_PULSE_LEN_MIN, - KASEIKYO_PULSE_LEN_MAX, - KASEIKYO_1_PAUSE_LEN_MIN, - KASEIKYO_1_PAUSE_LEN_MAX, - KASEIKYO_PULSE_LEN_MIN, - KASEIKYO_PULSE_LEN_MAX, - KASEIKYO_0_PAUSE_LEN_MIN, - KASEIKYO_0_PAUSE_LEN_MAX, - KASEIKYO_ADDRESS_OFFSET, - KASEIKYO_ADDRESS_OFFSET + KASEIKYO_ADDRESS_LEN, - KASEIKYO_COMMAND_OFFSET, - KASEIKYO_COMMAND_OFFSET + KASEIKYO_COMMAND_LEN, - KASEIKYO_COMPLETE_DATA_LEN, - KASEIKYO_STOP_BIT, - KASEIKYO_LSB + IRMP_KASEIKYO_PROTOCOL, // protocol: ir protocol + KASEIKYO_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + KASEIKYO_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + KASEIKYO_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + KASEIKYO_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + KASEIKYO_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0 + KASEIKYO_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0 + KASEIKYO_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0 + KASEIKYO_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0 + KASEIKYO_ADDRESS_OFFSET, // address_offset: address offset + KASEIKYO_ADDRESS_OFFSET + KASEIKYO_ADDRESS_LEN, // address_end: end of address + KASEIKYO_COMMAND_OFFSET, // command_offset: command offset + KASEIKYO_COMMAND_OFFSET + KASEIKYO_COMMAND_LEN, // command_end: end of command + KASEIKYO_COMPLETE_DATA_LEN, // complete_len: complete length of frame + KASEIKYO_STOP_BIT, // stop_bit: flag: frame has stop bit + KASEIKYO_LSB // lsb_first: flag: LSB first }; #endif @@ -790,22 +799,22 @@ static PROGMEM IRMP_PARAMETER kaseikyo_param = static PROGMEM IRMP_PARAMETER recs80_param = { - IRMP_RECS80_PROTOCOL, - RECS80_PULSE_LEN_MIN, - RECS80_PULSE_LEN_MAX, - RECS80_1_PAUSE_LEN_MIN, - RECS80_1_PAUSE_LEN_MAX, - RECS80_PULSE_LEN_MIN, - RECS80_PULSE_LEN_MAX, - RECS80_0_PAUSE_LEN_MIN, - RECS80_0_PAUSE_LEN_MAX, - RECS80_ADDRESS_OFFSET, - RECS80_ADDRESS_OFFSET + RECS80_ADDRESS_LEN, - RECS80_COMMAND_OFFSET, - RECS80_COMMAND_OFFSET + RECS80_COMMAND_LEN, - RECS80_COMPLETE_DATA_LEN, - RECS80_STOP_BIT, - RECS80_LSB + IRMP_RECS80_PROTOCOL, // protocol: ir protocol + RECS80_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + RECS80_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + RECS80_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + RECS80_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + RECS80_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0 + RECS80_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0 + RECS80_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0 + RECS80_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0 + RECS80_ADDRESS_OFFSET, // address_offset: address offset + RECS80_ADDRESS_OFFSET + RECS80_ADDRESS_LEN, // address_end: end of address + RECS80_COMMAND_OFFSET, // command_offset: command offset + RECS80_COMMAND_OFFSET + RECS80_COMMAND_LEN, // command_end: end of command + RECS80_COMPLETE_DATA_LEN, // complete_len: complete length of frame + RECS80_STOP_BIT, // stop_bit: flag: frame has stop bit + RECS80_LSB // lsb_first: flag: LSB first }; #endif @@ -814,22 +823,22 @@ static PROGMEM IRMP_PARAMETER recs80_param = static PROGMEM IRMP_PARAMETER rc5_param = { - IRMP_RC5_PROTOCOL, - RC5_BIT_LEN_MIN, - RC5_BIT_LEN_MAX, - RC5_BIT_LEN_MIN, - RC5_BIT_LEN_MAX, - 1, // tricky: use this as stop bit length - 1, - 1, - 1, - RC5_ADDRESS_OFFSET, - RC5_ADDRESS_OFFSET + RC5_ADDRESS_LEN, - RC5_COMMAND_OFFSET, - RC5_COMMAND_OFFSET + RC5_COMMAND_LEN, - RC5_COMPLETE_DATA_LEN, - RC5_STOP_BIT, - RC5_LSB + IRMP_RC5_PROTOCOL, // protocol: ir protocol + RC5_BIT_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + RC5_BIT_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + RC5_BIT_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + RC5_BIT_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0 + 1, // pulse_0_len_max: maximum length of pulse with bit value 0 + 1, // pause_0_len_min: minimum length of pause with bit value 0 + 1, // pause_0_len_max: maximum length of pause with bit value 0 + RC5_ADDRESS_OFFSET, // address_offset: address offset + RC5_ADDRESS_OFFSET + RC5_ADDRESS_LEN, // address_end: end of address + RC5_COMMAND_OFFSET, // command_offset: command offset + RC5_COMMAND_OFFSET + RC5_COMMAND_LEN, // command_end: end of command + RC5_COMPLETE_DATA_LEN, // complete_len: complete length of frame + RC5_STOP_BIT, // stop_bit: flag: frame has stop bit + RC5_LSB // lsb_first: flag: LSB first }; #endif @@ -838,22 +847,22 @@ static PROGMEM IRMP_PARAMETER rc5_param = static PROGMEM IRMP_PARAMETER denon_param = { - IRMP_DENON_PROTOCOL, - DENON_PULSE_LEN_MIN, - DENON_PULSE_LEN_MAX, - DENON_1_PAUSE_LEN_MIN, - DENON_1_PAUSE_LEN_MAX, - DENON_PULSE_LEN_MIN, - DENON_PULSE_LEN_MAX, - DENON_0_PAUSE_LEN_MIN, - DENON_0_PAUSE_LEN_MAX, - DENON_ADDRESS_OFFSET, - DENON_ADDRESS_OFFSET + DENON_ADDRESS_LEN, - DENON_COMMAND_OFFSET, - DENON_COMMAND_OFFSET + DENON_COMMAND_LEN, - DENON_COMPLETE_DATA_LEN, - DENON_STOP_BIT, - DENON_LSB + IRMP_DENON_PROTOCOL, // protocol: ir protocol + DENON_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + DENON_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + DENON_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + DENON_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + DENON_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0 + DENON_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0 + DENON_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0 + DENON_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0 + DENON_ADDRESS_OFFSET, // address_offset: address offset + DENON_ADDRESS_OFFSET + DENON_ADDRESS_LEN, // address_end: end of address + DENON_COMMAND_OFFSET, // command_offset: command offset + DENON_COMMAND_OFFSET + DENON_COMMAND_LEN, // command_end: end of command + DENON_COMPLETE_DATA_LEN, // complete_len: complete length of frame + DENON_STOP_BIT, // stop_bit: flag: frame has stop bit + DENON_LSB // lsb_first: flag: LSB first }; #endif @@ -862,22 +871,22 @@ static PROGMEM IRMP_PARAMETER denon_param = static PROGMEM IRMP_PARAMETER rc6_param = { - IRMP_RC6_PROTOCOL, - RC6_BIT_LEN_MIN, - RC6_BIT_LEN_MAX, - RC6_BIT_LEN_MIN, - RC6_BIT_LEN_MAX, - 1, // tricky: use this as stop bit length - 1, - 1, - 1, - RC6_ADDRESS_OFFSET, - RC6_ADDRESS_OFFSET + RC6_ADDRESS_LEN, - RC6_COMMAND_OFFSET, - RC6_COMMAND_OFFSET + RC6_COMMAND_LEN, - RC6_COMPLETE_DATA_LEN_SHORT, - RC6_STOP_BIT, - RC6_LSB + IRMP_RC6_PROTOCOL, // protocol: ir protocol + RC6_BIT_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + RC6_BIT_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + RC6_BIT_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + RC6_BIT_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0 + 1, // pulse_0_len_max: maximum length of pulse with bit value 0 + 1, // pause_0_len_min: minimum length of pause with bit value 0 + 1, // pause_0_len_max: maximum length of pause with bit value 0 + RC6_ADDRESS_OFFSET, // address_offset: address offset + RC6_ADDRESS_OFFSET + RC6_ADDRESS_LEN, // address_end: end of address + RC6_COMMAND_OFFSET, // command_offset: command offset + RC6_COMMAND_OFFSET + RC6_COMMAND_LEN, // command_end: end of command + RC6_COMPLETE_DATA_LEN_SHORT, // complete_len: complete length of frame + RC6_STOP_BIT, // stop_bit: flag: frame has stop bit + RC6_LSB // lsb_first: flag: LSB first }; #endif @@ -886,22 +895,22 @@ static PROGMEM IRMP_PARAMETER rc6_param = static PROGMEM IRMP_PARAMETER recs80ext_param = { - IRMP_RECS80EXT_PROTOCOL, - RECS80EXT_PULSE_LEN_MIN, - RECS80EXT_PULSE_LEN_MAX, - RECS80EXT_1_PAUSE_LEN_MIN, - RECS80EXT_1_PAUSE_LEN_MAX, - RECS80EXT_PULSE_LEN_MIN, - RECS80EXT_PULSE_LEN_MAX, - RECS80EXT_0_PAUSE_LEN_MIN, - RECS80EXT_0_PAUSE_LEN_MAX, - RECS80EXT_ADDRESS_OFFSET, - RECS80EXT_ADDRESS_OFFSET + RECS80EXT_ADDRESS_LEN, - RECS80EXT_COMMAND_OFFSET, - RECS80EXT_COMMAND_OFFSET + RECS80EXT_COMMAND_LEN, - RECS80EXT_COMPLETE_DATA_LEN, - RECS80EXT_STOP_BIT, - RECS80EXT_LSB + IRMP_RECS80EXT_PROTOCOL, // protocol: ir protocol + RECS80EXT_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + RECS80EXT_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + RECS80EXT_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + RECS80EXT_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + RECS80EXT_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0 + RECS80EXT_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0 + RECS80EXT_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0 + RECS80EXT_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0 + RECS80EXT_ADDRESS_OFFSET, // address_offset: address offset + RECS80EXT_ADDRESS_OFFSET + RECS80EXT_ADDRESS_LEN, // address_end: end of address + RECS80EXT_COMMAND_OFFSET, // command_offset: command offset + RECS80EXT_COMMAND_OFFSET + RECS80EXT_COMMAND_LEN, // command_end: end of command + RECS80EXT_COMPLETE_DATA_LEN, // complete_len: complete length of frame + RECS80EXT_STOP_BIT, // stop_bit: flag: frame has stop bit + RECS80EXT_LSB // lsb_first: flag: LSB first }; #endif @@ -910,22 +919,22 @@ static PROGMEM IRMP_PARAMETER recs80ext_param = static PROGMEM IRMP_PARAMETER nubert_param = { - IRMP_NUBERT_PROTOCOL, - NUBERT_1_PULSE_LEN_MIN, - NUBERT_1_PULSE_LEN_MAX, - NUBERT_1_PAUSE_LEN_MIN, - NUBERT_1_PAUSE_LEN_MAX, - NUBERT_0_PULSE_LEN_MIN, - NUBERT_0_PULSE_LEN_MAX, - NUBERT_0_PAUSE_LEN_MIN, - NUBERT_0_PAUSE_LEN_MAX, - NUBERT_ADDRESS_OFFSET, - NUBERT_ADDRESS_OFFSET + NUBERT_ADDRESS_LEN, - NUBERT_COMMAND_OFFSET, - NUBERT_COMMAND_OFFSET + NUBERT_COMMAND_LEN, - NUBERT_COMPLETE_DATA_LEN, - NUBERT_STOP_BIT, - NUBERT_LSB + IRMP_NUBERT_PROTOCOL, // protocol: ir protocol + NUBERT_1_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + NUBERT_1_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + NUBERT_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + NUBERT_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + NUBERT_0_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0 + NUBERT_0_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0 + NUBERT_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0 + NUBERT_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0 + NUBERT_ADDRESS_OFFSET, // address_offset: address offset + NUBERT_ADDRESS_OFFSET + NUBERT_ADDRESS_LEN, // address_end: end of address + NUBERT_COMMAND_OFFSET, // command_offset: command offset + NUBERT_COMMAND_OFFSET + NUBERT_COMMAND_LEN, // command_end: end of command + NUBERT_COMPLETE_DATA_LEN, // complete_len: complete length of frame + NUBERT_STOP_BIT, // stop_bit: flag: frame has stop bit + NUBERT_LSB // lsb_first: flag: LSB first }; #endif @@ -934,58 +943,58 @@ static PROGMEM IRMP_PARAMETER nubert_param = static PROGMEM IRMP_PARAMETER bang_olufsen_param = { - IRMP_BANG_OLUFSEN_PROTOCOL, - BANG_OLUFSEN_PULSE_LEN_MIN, - BANG_OLUFSEN_PULSE_LEN_MAX, - BANG_OLUFSEN_1_PAUSE_LEN_MIN, - BANG_OLUFSEN_1_PAUSE_LEN_MAX, - BANG_OLUFSEN_PULSE_LEN_MIN, - BANG_OLUFSEN_PULSE_LEN_MAX, - BANG_OLUFSEN_0_PAUSE_LEN_MIN, - BANG_OLUFSEN_0_PAUSE_LEN_MAX, - BANG_OLUFSEN_ADDRESS_OFFSET, - BANG_OLUFSEN_ADDRESS_OFFSET + BANG_OLUFSEN_ADDRESS_LEN, - BANG_OLUFSEN_COMMAND_OFFSET, - BANG_OLUFSEN_COMMAND_OFFSET + BANG_OLUFSEN_COMMAND_LEN, - BANG_OLUFSEN_COMPLETE_DATA_LEN, - BANG_OLUFSEN_STOP_BIT, - BANG_OLUFSEN_LSB + IRMP_BANG_OLUFSEN_PROTOCOL, // protocol: ir protocol + BANG_OLUFSEN_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + BANG_OLUFSEN_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + BANG_OLUFSEN_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + BANG_OLUFSEN_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + BANG_OLUFSEN_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0 + BANG_OLUFSEN_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0 + BANG_OLUFSEN_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0 + BANG_OLUFSEN_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0 + BANG_OLUFSEN_ADDRESS_OFFSET, // address_offset: address offset + BANG_OLUFSEN_ADDRESS_OFFSET + BANG_OLUFSEN_ADDRESS_LEN, // address_end: end of address + BANG_OLUFSEN_COMMAND_OFFSET, // command_offset: command offset + BANG_OLUFSEN_COMMAND_OFFSET + BANG_OLUFSEN_COMMAND_LEN, // command_end: end of command + BANG_OLUFSEN_COMPLETE_DATA_LEN, // complete_len: complete length of frame + BANG_OLUFSEN_STOP_BIT, // stop_bit: flag: frame has stop bit + BANG_OLUFSEN_LSB // lsb_first: flag: LSB first }; #endif -#if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1 +#if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1 static PROGMEM IRMP_PARAMETER grundig_param = { - IRMP_GRUNDIG_PROTOCOL, - GRUNDIG_BIT_LEN_MIN, - GRUNDIG_BIT_LEN_MAX, - GRUNDIG_BIT_LEN_MIN, - GRUNDIG_BIT_LEN_MAX, - 1, // tricky: use this as stop bit length - 1, - 1, - 1, - GRUNDIG_ADDRESS_OFFSET, - GRUNDIG_ADDRESS_OFFSET + GRUNDIG_ADDRESS_LEN, - GRUNDIG_COMMAND_OFFSET, - GRUNDIG_COMMAND_OFFSET + GRUNDIG_COMMAND_LEN, - GRUNDIG_COMPLETE_DATA_LEN, - GRUNDIG_STOP_BIT, - GRUNDIG_LSB + IRMP_GRUNDIG_PROTOCOL, // protocol: ir protocol + GRUNDIG_OR_NOKIA_BIT_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1 + GRUNDIG_OR_NOKIA_BIT_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1 + GRUNDIG_OR_NOKIA_BIT_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1 + GRUNDIG_OR_NOKIA_BIT_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1 + 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0 + 1, // pulse_0_len_max: maximum length of pulse with bit value 0 + 1, // pause_0_len_min: minimum length of pause with bit value 0 + 1, // pause_0_len_max: maximum length of pause with bit value 0 + GRUNDIG_ADDRESS_OFFSET, // address_offset: address offset + GRUNDIG_ADDRESS_OFFSET + GRUNDIG_ADDRESS_LEN, // address_end: end of address + GRUNDIG_COMMAND_OFFSET, // command_offset: command offset + GRUNDIG_COMMAND_OFFSET + GRUNDIG_COMMAND_LEN + 1, // command_end: end of command (USE 1 bit MORE to STORE NOKIA DATA!) + NOKIA_COMPLETE_DATA_LEN, // complete_len: complete length of frame, here: NOKIA instead of GRUNDIG! + GRUNDIG_OR_NOKIA_STOP_BIT, // stop_bit: flag: frame has stop bit + GRUNDIG_OR_NOKIA_LSB // lsb_first: flag: LSB first }; #endif -static uint8_t irmp_bit; // current bit position +static uint8_t irmp_bit; // current bit position static IRMP_PARAMETER irmp_param; static volatile uint8_t irmp_ir_detected; static volatile uint8_t irmp_protocol; static volatile uint16_t irmp_address; static volatile uint16_t irmp_command; -static volatile uint16_t irmp_id; // only used for SAMSUNG protocol +static volatile uint16_t irmp_id; // only used for SAMSUNG protocol static volatile uint8_t irmp_flags; #ifdef DEBUG @@ -1002,8 +1011,8 @@ void irmp_init (void) { #ifndef PIC_CCS_COMPILER - IRMP_PORT &= ~(1<= GRUNDIG_START_BIT_LEN_MIN && irmp_pulse_time <= GRUNDIG_START_BIT_LEN_MAX && - irmp_pause_time >= GRUNDIG_PRE_PAUSE_LEN_MIN && irmp_pause_time <= GRUNDIG_PRE_PAUSE_LEN_MAX) +#if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1 + if (irmp_pulse_time >= GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN && irmp_pulse_time <= GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX && + irmp_pause_time >= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN && irmp_pause_time <= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX) { // it's GRUNDIG DEBUG_PRINTF ("protocol = GRUNDIG, pre bit timings: pulse: %3d - %3d, pause: %3d - %3d\n", - GRUNDIG_START_BIT_LEN_MIN, GRUNDIG_START_BIT_LEN_MAX, - GRUNDIG_PRE_PAUSE_LEN_MIN, GRUNDIG_PRE_PAUSE_LEN_MAX); + GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN, GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX, + GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN, GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX); irmp_param_p = (IRMP_PARAMETER *) &grundig_param; last_pause = irmp_pause_time; last_value = 1; } else -#endif // IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1 +#endif // IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1 { DEBUG_PRINTF ("protocol = UNKNOWN\n"); @@ -1469,10 +1484,10 @@ irmp_ISR (void) else #endif // IRMP_SUPPORT_RC5_PROTOCOL == 1 -#if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1 - if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL) +#if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1 + if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL || irmp_param.protocol == IRMP_NOKIA_PROTOCOL) { - if (irmp_pause_time > GRUNDIG_START_BIT_LEN_MAX && irmp_pause_time <= 2 * GRUNDIG_START_BIT_LEN_MAX) + if (irmp_pause_time > GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX && irmp_pause_time <= 2 * GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX) { DEBUG_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter, irmp_bit, irmp_pulse_time, irmp_pause_time); DEBUG_PUTCHAR ('0'); @@ -1488,7 +1503,7 @@ irmp_ISR (void) } } else -#endif // IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1 +#endif // IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1 #if IRMP_SUPPORT_DENON_PROTOCOL == 1 if (irmp_param.protocol == IRMP_DENON_PROTOCOL) @@ -1526,7 +1541,10 @@ irmp_ISR (void) if (irmp_pulse_time >= irmp_param.pulse_0_len_min && irmp_pulse_time <= irmp_param.pulse_0_len_max) { #ifdef DEBUG - if (irmp_param.protocol != IRMP_RC5_PROTOCOL) + if (irmp_param.protocol != IRMP_RC5_PROTOCOL && + irmp_param.protocol != IRMP_RC6_PROTOCOL && + irmp_param.protocol != IRMP_GRUNDIG_PROTOCOL && + irmp_param.protocol != IRMP_NOKIA_PROTOCOL) { DEBUG_PRINTF ("stop bit detected\n"); } @@ -1578,10 +1596,39 @@ irmp_ISR (void) #endif #if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1 if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL && - irmp_pause_time > 2 * GRUNDIG_BIT_LEN_MAX && irmp_bit >= GRUNDIG_COMPLETE_DATA_LEN - 2 && !irmp_param.stop_bit) - { // special rc5 decoder - got_light = TRUE; // this is a lie, but generates a stop bit ;-) - irmp_param.stop_bit = TRUE; // set flag + irmp_pause_time > 2 * GRUNDIG_OR_NOKIA_BIT_LEN_MAX && irmp_bit >= GRUNDIG_COMPLETE_DATA_LEN - 2 && !irmp_param.stop_bit) + { // special Grundig/Nokia decoder + irmp_param.complete_len = GRUNDIG_COMPLETE_DATA_LEN; // correct complete len + got_light = TRUE; // this is a lie, but generates a stop bit ;-) + irmp_param.stop_bit = TRUE; // set flag + } + else +#endif +#if IRMP_SUPPORT_NOKIA_PROTOCOL == 1 + if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL && + irmp_bit >= GRUNDIG_COMPLETE_DATA_LEN) + { + DEBUG_PRINTF ("Switching to NOKIA protocol\n"); + irmp_param.protocol = IRMP_NOKIA_PROTOCOL; // change protocol + irmp_param.address_offset = NOKIA_ADDRESS_OFFSET; + irmp_param.address_end = NOKIA_ADDRESS_OFFSET + NOKIA_ADDRESS_LEN; + irmp_param.command_offset = NOKIA_COMMAND_OFFSET; + irmp_param.command_end = NOKIA_COMMAND_OFFSET + NOKIA_COMMAND_LEN; + + if (irmp_tmp_command & 0x300) + { + irmp_tmp_address = (irmp_tmp_command >> 8); + irmp_tmp_command &= 0xFF; + } + } + else +#endif +#if IRMP_SUPPORT_NOKIA_PROTOCOL == 1 + if (irmp_param.protocol == IRMP_NOKIA_PROTOCOL && + irmp_pause_time > 2 * GRUNDIG_OR_NOKIA_BIT_LEN_MAX && irmp_bit >= NOKIA_COMPLETE_DATA_LEN - 2 && !irmp_param.stop_bit) + { // special Grundig/Nokia decoder + got_light = TRUE; // this is a lie, but generates a stop bit ;-) + irmp_param.stop_bit = TRUE; // set flag } else #endif @@ -1649,10 +1696,11 @@ irmp_ISR (void) else #endif -#if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1 - if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL) // special Grundig decoder +#if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1 + if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL || // special Grundig decoder + irmp_param.protocol == IRMP_NOKIA_PROTOCOL) // special Nokia decoder { - if (irmp_pulse_time > GRUNDIG_BIT_LEN_MAX && irmp_pulse_time <= 2 * GRUNDIG_BIT_LEN_MAX) + if (irmp_pulse_time > GRUNDIG_OR_NOKIA_BIT_LEN_MAX && irmp_pulse_time <= 2 * GRUNDIG_OR_NOKIA_BIT_LEN_MAX) { DEBUG_PUTCHAR ('0'); irmp_store_bit (0); @@ -1662,11 +1710,11 @@ irmp_ISR (void) last_value = 1; } - else // if (irmp_pulse_time >= GRUNDIG_BIT_LEN_MIN && irmp_pulse_time <= GRUNDIG_BIT_LEN_MAX) + else // if (irmp_pulse_time >= GRUNDIG_BIT_LEN_MIN && irmp_pulse_time <= GRUNDIG_OR_NOKIA_BIT_LEN_MAX) { uint8_t grundig_value; - if (last_pause > GRUNDIG_BIT_LEN_MAX && last_pause <= 2 * GRUNDIG_BIT_LEN_MAX) + if (last_pause > GRUNDIG_OR_NOKIA_BIT_LEN_MAX && last_pause <= 2 * GRUNDIG_OR_NOKIA_BIT_LEN_MAX) { grundig_value = last_value ? 0 : 1; last_value = grundig_value; @@ -1810,7 +1858,7 @@ irmp_ISR (void) irmp_bit++; } else - { // timing incorrect! + { // timing incorrect! DEBUG_PRINTF ("error 3a B&O: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time); irmp_start_bit_detected = 0; // reset flags and wait for next start bit irmp_pause_time = 0; @@ -1903,7 +1951,7 @@ irmp_ISR (void) } else { // counting the pulse length ... - if (!irmp_input) // still light? + if (! irmp_input) // still light? { // yes... irmp_pulse_time++; // increment counter } @@ -1916,7 +1964,7 @@ irmp_ISR (void) if (irmp_bit == irmp_param.complete_len && irmp_param.stop_bit == 0) // enough bits received? { - if (last_irmp_command == irmp_tmp_command && repetition_counter < AUTO_REPETITION_LEN) + if (last_irmp_command == irmp_tmp_command && repetition_counter < AUTO_FRAME_REPETITION_LEN) { repetition_frame_number++; } @@ -1930,7 +1978,7 @@ irmp_ISR (void) if (irmp_param.protocol == IRMP_SIRCS_PROTOCOL && (repetition_frame_number == 1 || repetition_frame_number == 2)) { DEBUG_PRINTF ("code skipped: SIRCS auto repetition frame #%d, counter = %d, auto repetition len = %d\n", - repetition_frame_number + 1, repetition_counter, AUTO_REPETITION_LEN); + repetition_frame_number + 1, repetition_counter, AUTO_FRAME_REPETITION_LEN); repetition_counter = 0; } else @@ -1941,18 +1989,18 @@ irmp_ISR (void) if (irmp_param.protocol == IRMP_SAMSUNG32_PROTOCOL && (repetition_frame_number & 0x01)) { DEBUG_PRINTF ("code skipped: SAMSUNG32 auto repetition frame #%d, counter = %d, auto repetition len = %d\n", - repetition_frame_number + 1, repetition_counter, AUTO_REPETITION_LEN); + repetition_frame_number + 1, repetition_counter, AUTO_FRAME_REPETITION_LEN); repetition_counter = 0; } else #endif #if IRMP_SUPPORT_NUBERT_PROTOCOL == 1 - // if NUBERT protocol and the code will be repeated within 50 ms, we will ignore it. + // if NUBERT protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame if (irmp_param.protocol == IRMP_NUBERT_PROTOCOL && (repetition_frame_number & 0x01)) { DEBUG_PRINTF ("code skipped: NUBERT auto repetition frame #%d, counter = %d, auto repetition len = %d\n", - repetition_frame_number + 1, repetition_counter, AUTO_REPETITION_LEN); + repetition_frame_number + 1, repetition_counter, AUTO_FRAME_REPETITION_LEN); repetition_counter = 0; } else @@ -1984,14 +2032,22 @@ irmp_ISR (void) #endif // IRMP_SUPPORT_DENON_PROTOCOL #if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1 - if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL && irmp_tmp_command == 0x01ff) // only start frame? - { - DEBUG_PRINTF ("Detected start frame, ignoring it\n"); + if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL && irmp_tmp_command == 0x01ff) + { // Grundig start frame? + DEBUG_PRINTF ("Detected GRUNDIG start frame, ignoring it\n"); irmp_ir_detected = FALSE; - // last_irmp_grundig_command = irmp_tmp_command; } else -#endif // IRMP_SUPPORT_DENON_PROTOCOL +#endif // IRMP_SUPPORT_GRUNDIG_PROTOCOL + +#if IRMP_SUPPORT_NOKIA_PROTOCOL == 1 + if (irmp_param.protocol == IRMP_NOKIA_PROTOCOL && irmp_tmp_address == 0x00ff && irmp_tmp_command == 0x00fe) + { // Nokia start frame? + DEBUG_PRINTF ("Detected NOKIA start frame, ignoring it\n"); + irmp_ir_detected = FALSE; + } + else +#endif // IRMP_SUPPORT_NOKIA_PROTOCOL { #if IRMP_SUPPORT_NEC_PROTOCOL == 1 if (irmp_param.protocol == IRMP_NEC_PROTOCOL && irmp_bit == 0) // repetition frame @@ -2022,7 +2078,7 @@ irmp_ISR (void) { if (last_irmp_command == irmp_command && last_irmp_address == irmp_address && - repetition_counter < IRMP_REPETITION_TIME) + repetition_counter < IRMP_KEY_REPETITION_LEN) { irmp_flags |= IRMP_FLAG_REPETITION; } @@ -2049,7 +2105,7 @@ irmp_ISR (void) // Compile it under linux with: // cc irmp.c -o irmp // -// usage: ./irmp [-v|-s|-a] < file +// usage: ./irmp [-v|-s|-a|-p] < file static void print_timings (void) @@ -2088,8 +2144,8 @@ print_timings (void) BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN, BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX, BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN, BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX); printf ("BANG_OLUFSEN 4 %3d - %3d %3d - %3d\n", BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN, BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX); - printf ("GRUNDIG 1 %3d - %3d %3d - %3d\n", - GRUNDIG_START_BIT_LEN_MIN, GRUNDIG_START_BIT_LEN_MAX, GRUNDIG_PRE_PAUSE_LEN_MIN, GRUNDIG_PRE_PAUSE_LEN_MAX); + printf ("GRUNDIG/NOKIA 1 %3d - %3d %3d - %3d\n", + GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN, GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX, GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN, GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX); } int @@ -2313,7 +2369,7 @@ main (int argc, char ** argv) while ((ch = getchar()) != '\n' && ch != EOF) { - if (ch != '\r') // ignore CR in DOS/Windows files + if (ch != '\r') // ignore CR in DOS/Windows files { putchar (ch); } diff --git a/irmp.exe b/irmp.exe index 9dc5f4b6e4c9a251ad59c31f14e0bc463668b0c6..66afcf9d52b6ecb934874c86179c48a2d22f96a0 100644 GIT binary patch delta 6468 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 delta 6280 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 zYU9Daddress & 0x1F) << 3) | ((irmp_data_p->command & 0x0380) >> 7); // AAAAACCC - irsnd_buffer[1] = (irmp_data_p->command & 0x7F) << 1; // CCCCCCC0 - irsnd_buffer[2] = ((irmp_data_p->address & 0x1F) << 3) | (((~irmp_data_p->command) & 0x0380) >> 7); // AAAAACCC - irsnd_buffer[3] = (~(irmp_data_p->command) & 0x7F) << 1; // CCCCCCC0 + irsnd_buffer[0] = ((irmp_data_p->address & 0x1F) << 3) | ((irmp_data_p->command & 0x0380) >> 7); // AAAAACCC (1st frame) + irsnd_buffer[1] = (irmp_data_p->command & 0x7F) << 1; // CCCCCCC + irsnd_buffer[2] = ((irmp_data_p->address & 0x1F) << 3) | (((~irmp_data_p->command) & 0x0380) >> 7); // AAAAACCC (2nd frame) + irsnd_buffer[3] = (~(irmp_data_p->command) & 0x7F) << 1; // CCCCCCC irsnd_busy = TRUE; break; } @@ -419,10 +420,27 @@ irsnd_send_data (IRMP_DATA * irmp_data_p) { command = bitsrevervse (irmp_data_p->command, GRUNDIG_COMMAND_LEN); - irsnd_buffer[0] = 0xFF; // S1111111 - irsnd_buffer[1] = 0xC0; // 11000000 - irsnd_buffer[2] = 0x80 | (command >> 2); // SCCCCCCC - irsnd_buffer[3] = (command << 6) & 0xC0; // CC000000 + irsnd_buffer[0] = 0xFF; // S1111111 (1st frame) + irsnd_buffer[1] = 0xC0; // 11 + irsnd_buffer[2] = 0x80 | (command >> 2); // SCCCCCCC (2nd frame) + irsnd_buffer[3] = (command << 6) & 0xC0; // CC + + irsnd_busy = TRUE; + break; + } +#endif +#if IRSND_SUPPORT_NOKIA_PROTOCOL == 1 + case IRMP_NOKIA_PROTOCOL: + { + address = bitsrevervse (irmp_data_p->address, NOKIA_ADDRESS_LEN); + command = bitsrevervse (irmp_data_p->command, NOKIA_COMMAND_LEN); + + irsnd_buffer[0] = 0xBF; // S0111111 (1st + 3rd frame) + irsnd_buffer[1] = 0xFF; // 11111111 + irsnd_buffer[2] = 0x80; // 1 + irsnd_buffer[3] = 0x80 | command >> 1; // SCCCCCCC (2nd frame) + irsnd_buffer[4] = (command << 7) | (address >> 1); // CAAAAAAA + irsnd_buffer[5] = (address << 7); // A irsnd_busy = TRUE; break; @@ -459,7 +477,7 @@ irsnd_ISR (void) static uint8_t complete_data_len; static uint8_t n_frames; // number of repetitions static uint8_t frame_counter; // repetition counter - static uint16_t repetition_pause; // pause before repetition, uint16_t! + static uint16_t repetition_pause_len; // pause before repetition, uint16_t! static uint16_t repetition_pause_counter; // pause before repetition, uint16_t! #if IRSND_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1 static uint8_t last_bit_value; @@ -475,7 +493,7 @@ irsnd_ISR (void) { repetition_pause_counter++; - if (repetition_pause_counter >= repetition_pause) + if (repetition_pause_counter >= repetition_pause_len) { repetition_pause_counter = 0; @@ -489,6 +507,19 @@ irsnd_ISR (void) current_bit = 15; complete_data_len = 16 + GRUNDIG_COMPLETE_DATA_LEN; } + else if (irsnd_protocol == IRMP_NOKIA_PROTOCOL) + { + if (frame_counter == 1) + { + current_bit = 23; + complete_data_len = 24 + NOKIA_COMPLETE_DATA_LEN; + } + else // if (frame_counter == 2) + { + current_bit = 0xFF; + complete_data_len = NOKIA_COMPLETE_DATA_LEN; + } + } } else { @@ -515,16 +546,16 @@ irsnd_ISR (void) #if IRSND_SUPPORT_SIRCS_PROTOCOL == 1 case IRMP_SIRCS_PROTOCOL: { - startbit_pulse_len = SIRCS_START_BIT_PULSE_LEN; - startbit_pause_len = SIRCS_START_BIT_PAUSE_LEN; - pulse_1_len = SIRCS_1_PULSE_LEN; - pause_1_len = SIRCS_PAUSE_LEN; - pulse_0_len = SIRCS_0_PULSE_LEN; - pause_0_len = SIRCS_PAUSE_LEN; - has_stop_bit = SIRCS_STOP_BIT; - complete_data_len = SIRCS_MINIMUM_DATA_LEN; - n_frames = SIRCS_REPETITION_CNT; // 3 frames - repetition_pause = SIRCS_REPETITION_LEN; // 25ms pause + startbit_pulse_len = SIRCS_START_BIT_PULSE_LEN; + startbit_pause_len = SIRCS_START_BIT_PAUSE_LEN; + pulse_1_len = SIRCS_1_PULSE_LEN; + pause_1_len = SIRCS_PAUSE_LEN; + pulse_0_len = SIRCS_0_PULSE_LEN; + pause_0_len = SIRCS_PAUSE_LEN; + has_stop_bit = SIRCS_STOP_BIT; + complete_data_len = SIRCS_MINIMUM_DATA_LEN; + n_frames = SIRCS_FRAMES; // 3 frames + repetition_pause_len = SIRCS_FRAME_REPETITION_LEN; // 25ms pause irsnd_set_freq (IRSND_FREQ_40_KHZ); break; } @@ -532,16 +563,16 @@ irsnd_ISR (void) #if IRSND_SUPPORT_NEC_PROTOCOL == 1 case IRMP_NEC_PROTOCOL: { - startbit_pulse_len = NEC_START_BIT_PULSE_LEN; - startbit_pause_len = NEC_START_BIT_PAUSE_LEN; - pulse_1_len = NEC_PULSE_LEN; - pause_1_len = NEC_1_PAUSE_LEN; - pulse_0_len = NEC_PULSE_LEN; - pause_0_len = NEC_0_PAUSE_LEN; - has_stop_bit = NEC_STOP_BIT; - complete_data_len = NEC_COMPLETE_DATA_LEN; - n_frames = 1; // 1 frame - repetition_pause = 0; + startbit_pulse_len = NEC_START_BIT_PULSE_LEN; + startbit_pause_len = NEC_START_BIT_PAUSE_LEN; + pulse_1_len = NEC_PULSE_LEN; + pause_1_len = NEC_1_PAUSE_LEN; + pulse_0_len = NEC_PULSE_LEN; + pause_0_len = NEC_0_PAUSE_LEN; + has_stop_bit = NEC_STOP_BIT; + complete_data_len = NEC_COMPLETE_DATA_LEN; + n_frames = 1; // 1 frame + repetition_pause_len = 0; irsnd_set_freq (IRSND_FREQ_38_KHZ); break; } @@ -549,32 +580,32 @@ irsnd_ISR (void) #if IRSND_SUPPORT_SAMSUNG_PROTOCOL == 1 case IRMP_SAMSUNG_PROTOCOL: { - startbit_pulse_len = SAMSUNG_START_BIT_PULSE_LEN; - startbit_pause_len = SAMSUNG_START_BIT_PAUSE_LEN; - pulse_1_len = SAMSUNG_PULSE_LEN; - pause_1_len = SAMSUNG_1_PAUSE_LEN; - pulse_0_len = SAMSUNG_PULSE_LEN; - pause_0_len = SAMSUNG_0_PAUSE_LEN; - has_stop_bit = SAMSUNG_STOP_BIT; - complete_data_len = SAMSUNG_COMPLETE_DATA_LEN; - n_frames = 1; // 1 frame - repetition_pause = 0; + startbit_pulse_len = SAMSUNG_START_BIT_PULSE_LEN; + startbit_pause_len = SAMSUNG_START_BIT_PAUSE_LEN; + pulse_1_len = SAMSUNG_PULSE_LEN; + pause_1_len = SAMSUNG_1_PAUSE_LEN; + pulse_0_len = SAMSUNG_PULSE_LEN; + pause_0_len = SAMSUNG_0_PAUSE_LEN; + has_stop_bit = SAMSUNG_STOP_BIT; + complete_data_len = SAMSUNG_COMPLETE_DATA_LEN; + n_frames = 1; // 1 frame + repetition_pause_len = 0; irsnd_set_freq (IRSND_FREQ_38_KHZ); break; } case IRMP_SAMSUNG32_PROTOCOL: { - startbit_pulse_len = SAMSUNG_START_BIT_PULSE_LEN; - startbit_pause_len = SAMSUNG_START_BIT_PAUSE_LEN; - pulse_1_len = SAMSUNG_PULSE_LEN; - pause_1_len = SAMSUNG_1_PAUSE_LEN; - pulse_0_len = SAMSUNG_PULSE_LEN; - pause_0_len = SAMSUNG_0_PAUSE_LEN; - has_stop_bit = SAMSUNG_STOP_BIT; - complete_data_len = SAMSUNG32_COMPLETE_DATA_LEN; - n_frames = SAMSUNG32_REPETITION_CNT; // 2 frames - repetition_pause = SAMSUNG32_REPETITION_LEN; // 47 ms pause + startbit_pulse_len = SAMSUNG_START_BIT_PULSE_LEN; + startbit_pause_len = SAMSUNG_START_BIT_PAUSE_LEN; + pulse_1_len = SAMSUNG_PULSE_LEN; + pause_1_len = SAMSUNG_1_PAUSE_LEN; + pulse_0_len = SAMSUNG_PULSE_LEN; + pause_0_len = SAMSUNG_0_PAUSE_LEN; + has_stop_bit = SAMSUNG_STOP_BIT; + complete_data_len = SAMSUNG32_COMPLETE_DATA_LEN; + n_frames = SAMSUNG32_FRAMES; // 2 frames + repetition_pause_len = SAMSUNG32_FRAME_REPETITION_LEN; // 47 ms pause irsnd_set_freq (IRSND_FREQ_38_KHZ); break; } @@ -582,16 +613,16 @@ irsnd_ISR (void) #if IRSND_SUPPORT_MATSUSHITA_PROTOCOL == 1 case IRMP_MATSUSHITA_PROTOCOL: { - startbit_pulse_len = MATSUSHITA_START_BIT_PULSE_LEN; - startbit_pause_len = MATSUSHITA_START_BIT_PAUSE_LEN; - pulse_1_len = MATSUSHITA_PULSE_LEN; - pause_1_len = MATSUSHITA_1_PAUSE_LEN; - pulse_0_len = MATSUSHITA_PULSE_LEN; - pause_0_len = MATSUSHITA_0_PAUSE_LEN; - has_stop_bit = MATSUSHITA_STOP_BIT; - complete_data_len = MATSUSHITA_COMPLETE_DATA_LEN; - n_frames = 1; // 1 frame - repetition_pause = 0; + startbit_pulse_len = MATSUSHITA_START_BIT_PULSE_LEN; + startbit_pause_len = MATSUSHITA_START_BIT_PAUSE_LEN; + pulse_1_len = MATSUSHITA_PULSE_LEN; + pause_1_len = MATSUSHITA_1_PAUSE_LEN; + pulse_0_len = MATSUSHITA_PULSE_LEN; + pause_0_len = MATSUSHITA_0_PAUSE_LEN; + has_stop_bit = MATSUSHITA_STOP_BIT; + complete_data_len = MATSUSHITA_COMPLETE_DATA_LEN; + n_frames = 1; // 1 frame + repetition_pause_len = 0; irsnd_set_freq (IRSND_FREQ_36_KHZ); break; } @@ -599,16 +630,16 @@ irsnd_ISR (void) #if IRSND_SUPPORT_RECS80_PROTOCOL == 1 case IRMP_RECS80_PROTOCOL: { - startbit_pulse_len = RECS80_START_BIT_PULSE_LEN; - startbit_pause_len = RECS80_START_BIT_PAUSE_LEN; - pulse_1_len = RECS80_PULSE_LEN; - pause_1_len = RECS80_1_PAUSE_LEN; - pulse_0_len = RECS80_PULSE_LEN; - pause_0_len = RECS80_0_PAUSE_LEN; - has_stop_bit = RECS80_STOP_BIT; - complete_data_len = RECS80_COMPLETE_DATA_LEN; - n_frames = 1; // 1 frame - repetition_pause = 0; + startbit_pulse_len = RECS80_START_BIT_PULSE_LEN; + startbit_pause_len = RECS80_START_BIT_PAUSE_LEN; + pulse_1_len = RECS80_PULSE_LEN; + pause_1_len = RECS80_1_PAUSE_LEN; + pulse_0_len = RECS80_PULSE_LEN; + pause_0_len = RECS80_0_PAUSE_LEN; + has_stop_bit = RECS80_STOP_BIT; + complete_data_len = RECS80_COMPLETE_DATA_LEN; + n_frames = 1; // 1 frame + repetition_pause_len = 0; irsnd_set_freq (IRSND_FREQ_38_KHZ); break; } @@ -616,16 +647,16 @@ irsnd_ISR (void) #if IRSND_SUPPORT_RECS80EXT_PROTOCOL == 1 case IRMP_RECS80EXT_PROTOCOL: { - startbit_pulse_len = RECS80EXT_START_BIT_PULSE_LEN; - startbit_pause_len = RECS80EXT_START_BIT_PAUSE_LEN; - pulse_1_len = RECS80EXT_PULSE_LEN; - pause_1_len = RECS80EXT_1_PAUSE_LEN; - pulse_0_len = RECS80EXT_PULSE_LEN; - pause_0_len = RECS80EXT_0_PAUSE_LEN; - has_stop_bit = RECS80EXT_STOP_BIT; - complete_data_len = RECS80EXT_COMPLETE_DATA_LEN; - n_frames = 1; // 1 frame - repetition_pause = 0; + startbit_pulse_len = RECS80EXT_START_BIT_PULSE_LEN; + startbit_pause_len = RECS80EXT_START_BIT_PAUSE_LEN; + pulse_1_len = RECS80EXT_PULSE_LEN; + pause_1_len = RECS80EXT_1_PAUSE_LEN; + pulse_0_len = RECS80EXT_PULSE_LEN; + pause_0_len = RECS80EXT_0_PAUSE_LEN; + has_stop_bit = RECS80EXT_STOP_BIT; + complete_data_len = RECS80EXT_COMPLETE_DATA_LEN; + n_frames = 1; // 1 frame + repetition_pause_len = 0; irsnd_set_freq (IRSND_FREQ_38_KHZ); break; } @@ -633,16 +664,16 @@ irsnd_ISR (void) #if IRSND_SUPPORT_RC5_PROTOCOL == 1 case IRMP_RC5_PROTOCOL: { - startbit_pulse_len = RC5_BIT_LEN; - startbit_pause_len = RC5_BIT_LEN; - pulse_1_len = RC5_BIT_LEN; - pause_1_len = RC5_BIT_LEN; - pulse_0_len = RC5_BIT_LEN; - pause_0_len = RC5_BIT_LEN; - has_stop_bit = RC5_STOP_BIT; - complete_data_len = RC5_COMPLETE_DATA_LEN; - n_frames = 1; // 1 frame - repetition_pause = 0; + startbit_pulse_len = RC5_BIT_LEN; + startbit_pause_len = RC5_BIT_LEN; + pulse_1_len = RC5_BIT_LEN; + pause_1_len = RC5_BIT_LEN; + pulse_0_len = RC5_BIT_LEN; + pause_0_len = RC5_BIT_LEN; + has_stop_bit = RC5_STOP_BIT; + complete_data_len = RC5_COMPLETE_DATA_LEN; + n_frames = 1; // 1 frame + repetition_pause_len = 0; irsnd_set_freq (IRSND_FREQ_36_KHZ); break; } @@ -650,16 +681,16 @@ irsnd_ISR (void) #if IRSND_SUPPORT_DENON_PROTOCOL == 1 case IRMP_DENON_PROTOCOL: { - startbit_pulse_len = 0x00; - startbit_pause_len = 0x00; - pulse_1_len = DENON_PULSE_LEN; - pause_1_len = DENON_1_PAUSE_LEN; - pulse_0_len = DENON_PULSE_LEN; - pause_0_len = DENON_0_PAUSE_LEN; - has_stop_bit = DENON_STOP_BIT; - complete_data_len = DENON_COMPLETE_DATA_LEN; - n_frames = DENON_REPETITION_CNT; // 2 frames, 2nd with inverted command - repetition_pause = DENON_REPETITION_LEN; // 65 ms pause after 1st frame + startbit_pulse_len = 0x00; + startbit_pause_len = 0x00; + pulse_1_len = DENON_PULSE_LEN; + pause_1_len = DENON_1_PAUSE_LEN; + pulse_0_len = DENON_PULSE_LEN; + pause_0_len = DENON_0_PAUSE_LEN; + has_stop_bit = DENON_STOP_BIT; + complete_data_len = DENON_COMPLETE_DATA_LEN; + n_frames = DENON_FRAMES; // 2 frames, 2nd with inverted command + repetition_pause_len = DENON_FRAME_REPETITION_LEN; // 65 ms pause after 1st frame irsnd_set_freq (IRSND_FREQ_32_KHZ); break; } @@ -667,16 +698,16 @@ irsnd_ISR (void) #if IRSND_SUPPORT_NUBERT_PROTOCOL == 1 case IRMP_NUBERT_PROTOCOL: { - startbit_pulse_len = NUBERT_START_BIT_PULSE_LEN; - startbit_pause_len = NUBERT_START_BIT_PAUSE_LEN; - pulse_1_len = NUBERT_1_PULSE_LEN; - pause_1_len = NUBERT_1_PAUSE_LEN; - pulse_0_len = NUBERT_0_PULSE_LEN; - pause_0_len = NUBERT_0_PAUSE_LEN; - has_stop_bit = NUBERT_STOP_BIT; - complete_data_len = NUBERT_COMPLETE_DATA_LEN; - n_frames = NUBERT_REPETITION_CNT; // 2 frames - repetition_pause = NUBERT_REPETITION_LEN; // 35 ms pause + startbit_pulse_len = NUBERT_START_BIT_PULSE_LEN; + startbit_pause_len = NUBERT_START_BIT_PAUSE_LEN; + pulse_1_len = NUBERT_1_PULSE_LEN; + pause_1_len = NUBERT_1_PAUSE_LEN; + pulse_0_len = NUBERT_0_PULSE_LEN; + pause_0_len = NUBERT_0_PAUSE_LEN; + has_stop_bit = NUBERT_STOP_BIT; + complete_data_len = NUBERT_COMPLETE_DATA_LEN; + n_frames = NUBERT_FRAMES; // 2 frames + repetition_pause_len = NUBERT_FRAME_REPETITION_LEN; // 35 ms pause irsnd_set_freq (IRSND_FREQ_36_KHZ); break; } @@ -684,17 +715,17 @@ irsnd_ISR (void) #if IRSND_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1 case IRMP_BANG_OLUFSEN_PROTOCOL: { - startbit_pulse_len = BANG_OLUFSEN_START_BIT1_PULSE_LEN; - startbit_pause_len = BANG_OLUFSEN_START_BIT1_PAUSE_LEN; - pulse_1_len = BANG_OLUFSEN_PULSE_LEN; - pause_1_len = BANG_OLUFSEN_1_PAUSE_LEN; - pulse_0_len = BANG_OLUFSEN_PULSE_LEN; - pause_0_len = BANG_OLUFSEN_0_PAUSE_LEN; - has_stop_bit = BANG_OLUFSEN_STOP_BIT; - complete_data_len = BANG_OLUFSEN_COMPLETE_DATA_LEN; - n_frames = 1; // 1 frame - repetition_pause = 0; - last_bit_value = 0; + startbit_pulse_len = BANG_OLUFSEN_START_BIT1_PULSE_LEN; + startbit_pause_len = BANG_OLUFSEN_START_BIT1_PAUSE_LEN; + pulse_1_len = BANG_OLUFSEN_PULSE_LEN; + pause_1_len = BANG_OLUFSEN_1_PAUSE_LEN; + pulse_0_len = BANG_OLUFSEN_PULSE_LEN; + pause_0_len = BANG_OLUFSEN_0_PAUSE_LEN; + has_stop_bit = BANG_OLUFSEN_STOP_BIT; + complete_data_len = BANG_OLUFSEN_COMPLETE_DATA_LEN; + n_frames = 1; // 1 frame + repetition_pause_len = 0; + last_bit_value = 0; irsnd_set_freq (IRSND_FREQ_455_KHZ); break; } @@ -702,17 +733,34 @@ irsnd_ISR (void) #if IRSND_SUPPORT_GRUNDIG_PROTOCOL == 1 case IRMP_GRUNDIG_PROTOCOL: { - startbit_pulse_len = GRUNDIG_BIT_LEN; - startbit_pause_len = GRUNDIG_PRE_PAUSE_LEN; - pulse_1_len = GRUNDIG_BIT_LEN; - pause_1_len = GRUNDIG_BIT_LEN; - pulse_0_len = GRUNDIG_BIT_LEN; - pause_0_len = GRUNDIG_BIT_LEN; - has_stop_bit = GRUNDIG_STOP_BIT; - complete_data_len = GRUNDIG_COMPLETE_DATA_LEN; - n_frames = GRUNDIG_REPETITION_CNT; // 2 frames - repetition_pause = GRUNDIG_REPETITION_LEN; // 20msec pause - irsnd_set_freq (IRSND_FREQ_36_KHZ); + startbit_pulse_len = GRUNDIG_OR_NOKIA_BIT_LEN; + startbit_pause_len = GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN; + pulse_1_len = GRUNDIG_OR_NOKIA_BIT_LEN; + pause_1_len = GRUNDIG_OR_NOKIA_BIT_LEN; + pulse_0_len = GRUNDIG_OR_NOKIA_BIT_LEN; + pause_0_len = GRUNDIG_OR_NOKIA_BIT_LEN; + has_stop_bit = GRUNDIG_OR_NOKIA_STOP_BIT; + complete_data_len = GRUNDIG_COMPLETE_DATA_LEN; + n_frames = GRUNDIG_FRAMES; // 2 frames + repetition_pause_len = GRUNDIG_FRAME_REPETITION_LEN; // 20msec pause + irsnd_set_freq (IRSND_FREQ_38_KHZ); + break; + } +#endif +#if IRSND_SUPPORT_NOKIA_PROTOCOL == 1 + case IRMP_NOKIA_PROTOCOL: + { + startbit_pulse_len = GRUNDIG_OR_NOKIA_BIT_LEN; + startbit_pause_len = GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN; + pulse_1_len = GRUNDIG_OR_NOKIA_BIT_LEN; + pause_1_len = GRUNDIG_OR_NOKIA_BIT_LEN; + pulse_0_len = GRUNDIG_OR_NOKIA_BIT_LEN; + pause_0_len = GRUNDIG_OR_NOKIA_BIT_LEN; + has_stop_bit = GRUNDIG_OR_NOKIA_STOP_BIT; + complete_data_len = NOKIA_COMPLETE_DATA_LEN; + n_frames = NOKIA_FRAMES; // 2 frames + repetition_pause_len = NOKIA_FRAME_REPETITION_LEN; // 20msec pause + irsnd_set_freq (IRSND_FREQ_38_KHZ); break; } #endif @@ -980,12 +1028,15 @@ irsnd_ISR (void) } #endif // IRSND_SUPPORT_RC5_PROTOCOL -#if IRSND_SUPPORT_GRUNDIG_PROTOCOL == 1 +#if IRSND_SUPPORT_GRUNDIG_PROTOCOL == 1 || IRSND_SUPPORT_NOKIA_PROTOCOL == 1 case IRMP_GRUNDIG_PROTOCOL: + case IRMP_NOKIA_PROTOCOL: { uint8_t next_bit = FALSE; - if (current_bit == 0xFF || current_bit == 15) // start bit of 1st or 2nd frame + if (current_bit == 0xFF || // start bit of 1st frame + (irsnd_protocol == IRMP_GRUNDIG_PROTOCOL && current_bit == 15) || // start bit of 2nd frame (Grundig) + (irsnd_protocol == IRMP_NOKIA_PROTOCOL && (current_bit == 23 || current_bit == 47))) // start bit of 2nd/3rd frame (Nokia) { if (pulse_counter == 0) { @@ -1024,7 +1075,7 @@ irsnd_ISR (void) if (first_pulse) { - if (pulse_counter < GRUNDIG_BIT_LEN) + if (pulse_counter < GRUNDIG_OR_NOKIA_BIT_LEN) { if (pulse_counter == 0) { @@ -1032,7 +1083,7 @@ irsnd_ISR (void) } pulse_counter++; } - else if (pause_counter < GRUNDIG_BIT_LEN) + else if (pause_counter < GRUNDIG_OR_NOKIA_BIT_LEN) { if (pause_counter == 0) { @@ -1047,7 +1098,7 @@ irsnd_ISR (void) } else { - if (pause_counter < GRUNDIG_BIT_LEN) + if (pause_counter < GRUNDIG_OR_NOKIA_BIT_LEN) { if (pause_counter == 0) { @@ -1055,7 +1106,7 @@ irsnd_ISR (void) } pause_counter++; } - else if (pulse_counter < GRUNDIG_BIT_LEN) + else if (pulse_counter < GRUNDIG_OR_NOKIA_BIT_LEN) { if (pulse_counter == 0) { @@ -1094,7 +1145,7 @@ irsnd_ISR (void) } break; } -#endif // IRSND_SUPPORT_GRUNDIG_PROTOCOL +#endif // IRSND_SUPPORT_GRUNDIG_PROTOCOL || IRSND_SUPPORT_NOKIA_PROTOCOL default: { diff --git a/irsnd.exe b/irsnd.exe index 5bce0d73e4606cfaff8cae55630e45ff989a7ebb..e265b359fd60ea0f2423b6519709e9eb4c2ee4a6 100644 GIT binary patch delta 3295 zcmaJ@3v?4z8lFiTTbia*+J@31G==h#f|Hp$k2{&k1W*=m1q20ohz+EVMA8>p`~UBM z-1+aM{^|bduUzTb|MYJUP_0iBWua|!CyL4iAS(_|FEBFbL6*;dF^141>4io)J=wA? z$GAXO(1*jzE%WFB>xO!%KuvK{#7cJbp`#t2%DBFW=#9cel*%y6UbIrwxL84Xb9i=Q zf+aaI#y?>U2je^E zX}TO2s9^$E;T`$4u3jiOY^hGzeiyUku|xvp07Nl?F{ZE#GN72H2cg0lW%gGP!a2V0CJ<>w^ODwOHP95 z*GMe7I5T1;mf3OB{?Xl_i$k$E)H%ADupMSkG%^7m3VE81IX1Cg$}F$+h*@T+ zl?Z!Vhxkm#_?V`sy;EU|7h?}C07k^R5N3Obc#1oR8b~Sj4z5x(yB7c3sdx6w#v=azjYpD<}R-PrzuEA*A#u`gX8MVS7U zPLN1FB>L{pkZ5htZYFw!CI?Hr5`#k1U`wlk8SB0F2G5;cVP9uPyB(RBCi3@n` z#E^jm`E_n_&D1(JPJnTTdI<_OM9h*(kIeU z=?m$M)GYlZ-H>icHaSDik@I91RO@2du zOWrD1%lqXzxn4dle<`1q&&fZ@H{@G#BDUcSoP(X%g=Or)_u-Lv44#0e;-~Ozybzb* zAYO&n;f*+ix8iEN8-I*H#SQo?{4G9@FXF4X#fNDnNy%1vD7}?Jg;x}1urgd3t&CTm zRGwDmD)SVdvQ#No)+w(mZz@}rYUO}(SUIIMDL*Qgl-o*zyOTT3o#XE9=G`9mgYL2J zr`?8oqx)TV*j?xT%ze`RgZqN}rkheT)NFN>`mp-AI#Zpama5CuRqE@iuSPwho>0G3 zPpjXlQT4KVUHw&!sYzP8=FoCAr`A_1)C5h{hG@gJ$=VEUfwoLrrLEUCYgO8IZI4!~ zMYN+@qxO|{Ub~?Eq}|jgPl`wI4D(F!%=9es1U-i54bNuJHqTDae$QdganCoNX3td* zrCasE`dFX-gg#gI>#Ouv^^N*F`Zj%s{*fNh8}&2#IsJluMZcj#FFPr!h=!}kCbJH< z8{3l|z`9tC9m0-gA7-bq)7e?@7CQmFJRNFT2*bUUT{0bnSEF9p+5SoJK`;Z?kMJv%-v;qAUy@NhLJJ3EVDw?;UQtBFh|%e{9T9$$AqtiZ-uKul9(ah1Gncv zafP^AtQL2QpNsRPMbc{N1F2T}hs4UFtjUw)EpnCovz&$V@j#p_U=5GJ&){P0$4l`_ TycTc36?ij#4~M(3@6i7N?*~n! delta 2949 zcmZ`)2~}Sw z#29rtTGP}BxPbeE)kd3IKBTH;6Tplf6l+$?=Ii{@4Np@ z`LyzB4R^C5Q|`TtwT~N^36H^hVpuW&@nP^mmfi<1FhxJn2jNAysMq1InY1MRdwd)2 z_Scw};V*0)?8MxSr9A>>biz-a?LNF={bHoo^CQ_$9UPGp2BF6c91 z7;$Knsb)-e^oOy`#bda>HL4V^)#vp{g!TCzh4?z-yv|?UVUGDjVO<$0#3e4SUhRVV13Pt)=3ji&9gbNk6}*f?Zg)Mabmd% zPOJ^~-EmGVEHo-iLCJZA^iMz3waPv^Ca(j{!$o-~$5&NTvstXYa z>I)D?xSI{38hA0HdKFZ3`Wnkxkfy&ly(WB6EbBpDIGkxgh+f|-jamv$wU##lE`LH0 zRWm{KSP)0RTn1ora4a%NFzR}daDNo7C&pwZ*MkZy)}XEO2^851R#4+_()Cd>*+V^m zdlFU~YXhtS^GamttAZ7nQ4+yssAjxWG zmth}kz}%oeipd*@0$9V80D)i*bK>D^WO~xNaufQ<*kl6vBnQkW&7LUE(%2k}k$D<| z5b~GU0ak<*c{-tMvAKpLcyv0(St!FX&e!2M+7ds$E8#8p8b>DK9XGc4mKzK!V72%V zLpT~FjdHhi%e`0k+`am7OEQmqCUs^7LPj^A_<*@<;XIZaFu7Ht+pMWB$SrGZD10z`kzAXANaO@$y(rOrvDDn!_G2jY?4-v~1m88G7Dmk~pZ}R2fx#7^ zCk`4tN*qim)7SM*n2K_E))+7w&&`J<*(hmg7TxGWl`ydI<#8Y4_ZhJ=Ar=jOs3=|W zXanzJ_z2f~^l^+tp5;$^LRu}5_JjM7c9X|~(BKvv)fq)a2Kk1;kL?BqS6Nqsh1Y8> z_4@ig1v$IGCSXP(;EN(dESL+HUUU^TM7WPaGpdB16eqjF>}H}OGZYGSaG4kN4^mxa zq9V%>JFV|O3x$ku&l-Iws%$h4Q860Ky#KFqL{$!`17@Vhf^jIK2{OJE_Z;tncwu(g zf<7owQ4dIa@a|XX>__iLosKV!`s)1)xdrSW`0swj%vq0hJ7hu zCt(s`_cqMqsZOje&53=G4q3s7z;KxGYlfM+|FwXmH^#pgJLGOCbmDLfhPD2-O<$BS z%A^kPpH3(Pcl;VEBmjZGWrs{^pBo`d>4$A>Ld467|-M z_@SrzIkC$y(SUM=(0;ak?~ot1hwYHBbkVQLabnwZ{DU%2#^85#bN*o0Df*xEzvx!_ zHvNdUGAv_f3Yj9Ngqh9MGn<%g%ueP5rkT0JU~Ci{!;-9>EoLXMliBI)a<-DKWgFO? z>^}A|`w4rRjpVFc5|_sH=bqz8j^#v7<(yn0H=G;6jpD{|j|ckrY5@%$uy7C)a~!mr>fcn@FCZ{WTB zd;A{$0Dp{c;?MA(@t67Q{P+Al{xKioEkeAIBJ>mTgaUyRRAI1CB#aX#3R8vI!UAEL z;1cQtUDzya7ycyd7F_#<6GF4_sc=EKB77};E8G(v3n3v&w21LyikKxbqAWVaq2dU! zSezhE7H5ca#g(F4tQ8x?jp9~ur?^|(FCGyC;#u*McvZY1eka}*ABg`IBcz^EqLe0O zOD{;YBuP$bm^4y)MVcs0lNL%Vq&jK6^o~pVqqJW-BpsJdO6R1j(!Ztq5-vx{>GCl7 z*YfM~40(xMA+MG<%iH9=@&P#@e=3`lXeCZbQL+?4u`7d=k;-DlrMQ(^r9s)CY*l>9 zpOrm|Upb~UD=o@r$`{I4$_*u`+*KYbPZdHU4FETB??*L;ovokHi(`E)70oUWv6>2>r5dJDaS zexKe)AEM9DpVME`H|ZbfUW|=NWKx+dCXX4&@W#t|nJH!_FjJUW%mU_3rkYv9yv1yR zH?)^I#xyeLnJ<~In48Qa<{2}L{S`Zwo%jknlby>}u$x#Pdz3xTUSpHF40tp{;F(18 z7CwWw^P~B3d?O#=&q0q1(9x@eox+F0apAOZPPi)kB$!2;m?)+~v*w8fA`1=cf0f*Y J>y4(u{{bX+(s=*? diff --git a/irsndconfig.h b/irsndconfig.h index 81772bf..f08506e 100644 --- a/irsndconfig.h +++ b/irsndconfig.h @@ -3,7 +3,7 @@ * * Copyright (c) 2010 Frank Meyer - frank(at)fli4l.de * - * $Id: irsndconfig.h,v 1.2 2010/05/17 10:31:43 fm Exp $ + * $Id: irsndconfig.h,v 1.3 2010/05/26 08:34:30 fm Exp $ * * ATMEGA88 @ 8 MHz * @@ -34,6 +34,7 @@ #define IRSND_SUPPORT_NUBERT_PROTOCOL 1 // flag: support NUBERT uses ~100 bytes #define IRSND_SUPPORT_BANG_OLUFSEN_PROTOCOL 1 // flag: support Bang&Olufsen uses ~250 bytes #define IRSND_SUPPORT_GRUNDIG_PROTOCOL 1 // flag: support Grundig uses ~250 bytes +#define IRSND_SUPPORT_NOKIA_PROTOCOL 1 // flag: support Nokia uses ~150 bytes /*--------------------------------------------------------------------------------------------------------------------------------------------------- -- 2.39.2