514 lines
15 KiB
C++
514 lines
15 KiB
C++
#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
|