#define TEST 0

#if TEST

# define SEND_PRONTO 1

# define PRONTO_ONCE false

# define PRONTO_REPEAT true

# define PRONTO_FALLBACK true

# define PRONTO_NOFALLBACK false

#endif

#if SEND_PRONTO

//******************************************************************************

#if TEST

# include <stdio.h>

void enableIROut (int freq) { printf("\nFreq = %d KHz\n", freq); }

void mark (int t) { printf("+%d," , t); }

void space (int t) { printf("-%d, ", t); }

#else

# include "IRremote.h"

#endif // TEST

//+=============================================================================

// Check for a valid hex digit

//

bool ishex (char ch)

{

return ( ((ch >= '0') && (ch <= '9')) ||

((ch >= 'A') && (ch <= 'F')) ||

((ch >= 'a') && (ch <= 'f')) ) ? true : false ;

}

//+=============================================================================

// Check for a valid "blank" ... '\0' is a valid "blank"

//

bool isblank (char ch)

{

return ((ch == ' ') || (ch == '\t') || (ch == '\0')) ? true : false ;

}

//+=============================================================================

// Bypass spaces

//

bool byp (char** pcp)

{

while (isblank(**pcp)) (*pcp)++ ;

}

//+=============================================================================

// Hex-to-Byte : Decode a hex digit

// We assume the character has already been validated

//

uint8_t htob (char ch)

{

if ((ch >= '0') && (ch <= '9')) return ch - '0' ;

if ((ch >= 'A') && (ch <= 'F')) return ch - 'A' + 10 ;

if ((ch >= 'a') && (ch <= 'f')) return ch - 'a' + 10 ;

}

//+=============================================================================

// Hex-to-Word : Decode a block of 4 hex digits

// We assume the string has already been validated

// and the pointer being passed points at the start of a block of 4 hex digits

//

uint16_t htow (char* cp)

{

return ( (htob(cp[0]) << 12) | (htob(cp[1]) << 8) |

(htob(cp[2]) << 4) | (htob(cp[3]) ) ) ;

}

//+=============================================================================

//

bool sendPronto (char* s, bool repeat, bool fallback)

{

int i;

int len;

int skip;

char* cp;

uint16_t freq; // Frequency in KHz

uint8_t usec; // pronto uSec/tick

uint8_t once;

uint8_t rpt;

// Validate the string

for (cp = s; *cp; cp += 4) {

byp(&cp);

if ( !ishex(cp[0]) || !ishex(cp[1]) ||

!ishex(cp[2]) || !ishex(cp[3]) || !isblank(cp[4]) ) return false ;

}

// We will use cp to traverse the string

cp = s;

// Check mode = Oscillated/Learned

byp(&cp);

if (htow(cp) != 0000) return false;

cp += 4;

// Extract & set frequency

byp(&cp);

freq = (int)(1000000 / (htow(cp) * 0.241246)); // Rounding errors will occur, tolerance is +/- 10%

usec = (int)(((1.0 / freq) * 1000000) + 0.5); // Another rounding error, thank Cod for analogue electronics

freq /= 1000; // This will introduce a(nother) rounding error which we do not want in the usec calcualtion

cp += 4;

// Get length of "once" code

byp(&cp);

once = htow(cp);

cp += 4;

// Get length of "repeat" code

byp(&cp);

rpt = htow(cp);

cp += 4;

// Which code are we sending?

if (fallback) { // fallback on the "other" code if "this" code is not present

if (!repeat) { // requested 'once'

if (once) len = once * 2, skip = 0 ; // if once exists send it

else len = rpt * 2, skip = 0 ; // else send repeat code

} else { // requested 'repeat'

if (rpt) len = rpt * 2, skip = 0 ; // if rpt exists send it

else len = once * 2, skip = 0 ; // else send once code

}

} else { // Send what we asked for, do not fallback if the code is empty!

if (!repeat) len = once * 2, skip = 0 ; // 'once' starts at 0

else len = rpt * 2, skip = once ; // 'repeat' starts where 'once' ends

}

// Skip to start of code

for (i = 0; i < skip; i++, cp += 4) byp(&cp) ;

// Send code

enableIROut(freq);

for (i = 0; i < len; i++) {

byp(&cp);

if (i & 1) space(htow(cp) * usec);

else mark (htow(cp) * usec);

cp += 4;

}

}

//+=============================================================================

#if TEST

int main ( )

{

char prontoTest[] =

"0000 0070 0000 0032 0080 0040 0010 0010 0010 0030 " // 10

"0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 " // 20

"0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 " // 30

"0010 0010 0010 0030 0010 0010 0010 0010 0010 0010 " // 40

"0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 " // 50

"0010 0010 0010 0030 0010 0010 0010 0010 0010 0010 " // 60

"0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 " // 70

"0010 0010 0010 0030 0010 0010 0010 0030 0010 0010 " // 80

"0010 0010 0010 0030 0010 0010 0010 0010 0010 0030 " // 90

"0010 0010 0010 0030 0010 0010 0010 0010 0010 0030 " // 100

"0010 0030 0010 0aa6"; // 104

sendPronto(prontoTest, PRONTO_ONCE, PRONTO_FALLBACK); // once code

sendPronto(prontoTest, PRONTO_REPEAT, PRONTO_FALLBACK); // repeat code

sendPronto(prontoTest, PRONTO_ONCE, PRONTO_NOFALLBACK); // once code

sendPronto(prontoTest, PRONTO_REPEAT, PRONTO_NOFALLBACK); // repeat code

return 0;

}

#endif // TEST

#endif // SEND_PRONTO

#if 0

//******************************************************************************

// Sources:

// http://www.remotecentral.com/features/irdisp2.htm

// http://www.hifi-remote.com/wiki/index.php?title=Working_With_Pronto_Hex

//******************************************************************************

#include <stdint.h>

#include <stdio.h>

#define IRPRONTO

#include "IRremoteInt.h" // The Arduino IRremote library defines USECPERTICK

//------------------------------------------------------------------------------

// Source: https://www.google.co.uk/search?q=DENON+MASTER+IR+Hex+Command+Sheet

// -> http://assets.denon.com/documentmaster/us/denon%20master%20ir%20hex.xls

//

char prontoTest[] =

"0000 0070 0000 0032 0080 0040 0010 0010 0010 0030 " // 10

"0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 " // 20

"0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 " // 30

"0010 0010 0010 0030 0010 0010 0010 0010 0010 0010 " // 40

"0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 " // 50

"0010 0010 0010 0030 0010 0010 0010 0010 0010 0010 " // 60

"0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 " // 70

"0010 0010 0010 0030 0010 0010 0010 0030 0010 0010 " // 80

"0010 0010 0010 0030 0010 0010 0010 0010 0010 0030 " // 90

"0010 0010 0010 0030 0010 0010 0010 0010 0010 0030 " // 100

"0010 0030 0010 0aa6"; // 104

//------------------------------------------------------------------------------

// This is the longest code we can support

#define CODEMAX 200

//------------------------------------------------------------------------------

// This is the data we pull out of the pronto code

typedef

struct {

int freq; // Carrier frequency (in Hz)

int usec; // uSec per tick (based on freq)

int codeLen; // Length of code

uint16_t code[CODEMAX]; // Code in hex

int onceLen; // Length of "once" transmit

uint16_t* once; // Pointer to start within 'code'

int rptLen; // Length of "repeat" transmit

uint16_t* rpt; // Pointer to start within 'code'

}

pronto_t;

//------------------------------------------------------------------------------

// From what I have seen, the only time we go over 8-bits is the 'space'

// on the end which creates the lead-out/inter-code gap. Assuming I'm right,

// we can code this up as a special case and otherwise halve the size of our

// data!

// Ignoring the first four values (the config data) and the last value

// (the lead-out), if you find a protocol that uses values greater than 00fe

// we are going to have to revisit this code!

//

//

// So, the 0th byte will be the carrier frequency in Khz (NOT Hz)

// " 1st " " " " length of the "once" code

// " 2nd " " " " length of the "repeat" code

//

// Thereafter, odd bytes will be Mark lengths as a multiple of USECPERTICK uS

// even " " " Space " " " " " " "

//

// Any occurence of "FF" in either a Mark or a Space will indicate

// "Use the 16-bit FF value" which will also be a multiple of USECPERTICK uS

//

//

// As a point of comparison, the test code (prontoTest[]) is 520 bytes

// (yes, more than 0.5KB of our Arduino's precious 32KB) ... after conversion

// to pronto hex that goes down to ((520/5)*2) = 208 bytes ... once converted to

// our format we are down to ((208/2) -1 -1 +2) = 104 bytes

//

// In fariness this is still very memory-hungry

// ...As a rough guide:

// 10 codes cost 1K of memory (this will vary depending on the protocol).

//

// So if you're building a complex remote control, you will probably need to

// keep the codes on an external memory device (not in the Arduino sketch) and

// load them as you need them. Hmmm.

//

// This dictates that "Oscillated Pronto Codes" are probably NOT the way forward

//

// For example, prontoTest[] happens to be: A 48-bit IR code in Denon format

// So we know it starts with 80/40 (Denon header)

// and ends with 10/aa6 (Denon leadout)

// and all (48) bits in between are either 10/10 (Denon 0)

// or 10/30 (Denon 1)

// So we could easily store this data in 1-byte ("Denon")

// + 1-byte (Length=48)

// + 6-bytes (IR code)

// At 8-bytes per code, we can store 128 codes in 1KB or memory - that's a lot

// better than the 2 (two) we started off with!

//

// And serendipitously, by reducing the amount of data, our program will run

// a LOT faster!

//

// Again, I repeat, even after you have spent time converting the "Oscillated

// Pronto Codes" in to IRremote format, it will be a LOT more memory-hungry

// than using sendDenon() (or whichever) ...BUT these codes are easily

// available on the internet, so we'll support them!

//

typedef

struct {

uint16_t FF;

uint8_t code[CODEMAX];

}

irCode_t;

//------------------------------------------------------------------------------

#define DEBUGF(...) printf(__VA_ARGS__)

//+=============================================================================

// String must be block of 4 hex digits separated with blanks

//

bool validate (char* cp, int* len)

{

for (*len = 0; *cp; (*len)++, cp += 4) {

byp(&cp);

if ( !ishex(cp[0]) || !ishex(cp[1]) ||

!ishex(cp[2]) || !ishex(cp[3]) || !isblank(cp[4]) ) return false ;

}

return true;

}

//+=============================================================================

// Hex-to-Byte : Decode a hex digit

// We assume the character has already been validated

//

uint8_t htob (char ch)

{

if ((ch >= '0') && (ch <= '9')) return ch - '0' ;

if ((ch >= 'A') && (ch <= 'F')) return ch - 'A' + 10 ;

if ((ch >= 'a') && (ch <= 'f')) return ch - 'a' + 10 ;

}

//+=============================================================================

// Hex-to-Word : Decode a block of 4 hex digits

// We assume the string has already been validated

// and the pointer being passed points at the start of a block of 4 hex digits

//

uint16_t htow (char* cp)

{

return ( (htob(cp[0]) << 12) | (htob(cp[1]) << 8) |

(htob(cp[2]) << 4) | (htob(cp[3]) ) ) ;

}

//+=============================================================================

// Convert the pronto string in to data

//

bool decode (char* s, pronto_t* p, irCode_t* ir)

{

int i, len;

char* cp;

// Validate the Pronto string

if (!validate(s, &p->codeLen)) {

DEBUGF("Invalid pronto string\n");

return false ;

}

DEBUGF("Found %d hex codes\n", p->codeLen);

// Allocate memory to store the decoded string

//if (!(p->code = malloc(p->len))) {

// DEBUGF("Memory allocation failed\n");

// return false ;

//}

// Check in case our code is too long

if (p->codeLen > CODEMAX) {

DEBUGF("Code too long, edit CODEMAX and recompile\n");

return false ;

}

// Decode the string

cp = s;

for (i = 0; i < p->codeLen; i++, cp += 4) {

byp(&cp);

p->code[i] = htow(cp);

}

// Announce our findings

DEBUGF("Input: |%s|\n", s);

DEBUGF("Found: |");

for (i = 0; i < p->codeLen; i++) DEBUGF("%04x ", p->code[i]) ;

DEBUGF("|\n");

DEBUGF("Form [%04X] : ", p->code[0]);

if (p->code[0] == 0x0000) DEBUGF("Oscillated (Learned)\n");

else if (p->code[0] == 0x0100) DEBUGF("Unmodulated\n");

else DEBUGF("Unknown\n");

if (p->code[0] != 0x0000) return false ; // Can only handle Oscillated

// Calculate the carrier frequency (+/- 10%) & uSecs per pulse

// Pronto uses a crystal which generates a timeabse of 0.241246

p->freq = (int)(1000000 / (p->code[1] * 0.241246));

p->usec = (int)(((1.0 / p->freq) * 1000000) + 0.5);

ir->code[0] = p->freq / 1000;

DEBUGF("Freq [%04X] : %d Hz (%d uS/pluse) -> %d KHz\n",

p->code[1], p->freq, p->usec, ir->code[0]);

// Set the length & start pointer for the "once" code

p->onceLen = p->code[2];

p->once = &p->code[4];

ir->code[1] = p->onceLen;

DEBUGF("Once [%04X] : %d\n", p->code[2], p->onceLen);

// Set the length & start pointer for the "repeat" code

p->rptLen = p->code[3];

p->rpt = &p->code[4 + p->onceLen];

ir->code[2] = p->rptLen;

DEBUGF("Rpt [%04X] : %d\n", p->code[3], p->rptLen);

// Check everything tallies

if (1 + 1 + 1 + 1 + (p->onceLen * 2) + (p->rptLen * 2) != p->codeLen) {

DEBUGF("Bad code length\n");

return false;

}

// Convert the IR data to our new format

ir->FF = p->code[p->codeLen - 1];

len = (p->onceLen * 2) + (p->rptLen * 2);

DEBUGF("Encoded: |");

for (i = 0; i < len; i++) {

if (p->code[i+4] == ir->FF) {

ir->code[i+3] = 0xFF;

} else if (p->code[i+4] > 0xFE) {

DEBUGF("\n%04X : Mark/Space overflow\n", p->code[i+4]);

return false;

} else {

ir->code[i+3] = (p->code[i+4] * p->usec) / USECPERTICK;

}

DEBUGF("%s%d", !i ? "" : (i&1 ? "," : ", "), ir->code[i+3]);

}

DEBUGF("|\n");

ir->FF = (ir->FF * p->usec) / USECPERTICK;

DEBUGF("FF -> %d\n", ir->FF);

return true;

}

//+=============================================================================

//

void irDump (irCode_t* ir)

{

int i, len;

printf("uint8_t buttonName[%d] = {", len);

printf("%d,%d, ", (ir->FF >> 8), ir->FF & 0xFF);

printf("%d,%d,%d, ", ir->code[0], ir->code[1], ir->code[2]);

len = (ir->code[1] * 2) + (ir->code[2] * 2);

for (i = 0; i < len; i++) {

printf("%s%d", !i ? "" : (i&1 ? "," : ", "), ir->code[i+3]);

}

printf("};\n");

}

//+=============================================================================

//

int main ( )

{

pronto_t pCode;

irCode_t irCode;

decode(prontoTest, &pCode, &irCode);

irDump(&irCode);

return 0;

}

#endif //0