void IR_constructor::NEC_cmd_create(BYTE irAddress, BYTE irExtAddr, BYTE irCommand, bool useExtAddr, CString label, bool useTestSend)//create 2 commands for toggle!
{
//toggle or repeat - not used for NEC
CString strTemp = _T("carrier=38000 pulses=21 duty=4 label=");
label.TrimRight();
strTemp += label;
resetBitArray();
//shortest uses bit-time 560mkS = 21 cycles of 38kHz = min lenght 21 pulses !
//max lenght for one byte = 32 bit, use byte-pack...
//start burst 16x1 8x0, 9ms freq, 4.5ms pause (3bytes used, one free)
//bitCmdFromMost[0] = 0xFFFF0000;//0b11111111 11111111 00000000 00000000 - last 8 free!
bitArray[0] = 0xFF;
bitArray[1] = 0xFF;
bytePointer = 3;//set start byte
//set ext addr according...
if(!useExtAddr) irExtAddr = ~irAddress;
BYTE negCommand = ~irCommand;//negative command
//set low address... (8 bit)
UINT bitCounter = 0;
while(bitCounter++ < 8)
{
addNextBitToArray(1);
addNextBitToArray(0);
if((irAddress & 0x01) != 0) {addNextBitToArray(0); addNextBitToArray(0);}//long for 1
irAddress >>= 1;
}

//next load address... (or inverted)
bitCounter = 0;
while(bitCounter++ < 8)
{
addNextBitToArray(1);
addNextBitToArray(0);
if((irExtAddr & 0x01) != 0) {addNextBitToArray(0); addNextBitToArray(0);}//long for 1
irExtAddr >>= 1;
}

//next load command...
bitCounter = 0;
while(bitCounter++ < 8)
{
addNextBitToArray(1);
addNextBitToArray(0);
if((irCommand & 0x01) != 0) {addNextBitToArray(0); addNextBitToArray(0);}//long for 1
irCommand >>= 1;
}

//next load inverted command...
bitCounter = 0;
while(bitCounter++ < 8)
{
addNextBitToArray(1);
addNextBitToArray(0);
if((negCommand & 0x01) != 0) {addNextBitToArray(0); addNextBitToArray(0);}//long for 1
negCommand >>= 1;
}

//all nec loaded, convert to string...
strTemp += _T(" 00");//set transmission bytes start 00
CString strTemp2;
UINT tmpCounter = 0;
while(tmpCounter <= bytePointer)
{
strTemp2.Format( "%.2X", bitArray[tmpCounter]);
strTemp += strTemp2;
tmpCounter++;
}

strTemp += _T("00\r\n");//set transmission bytes end
//can send (but toggle)
if(useTestSend)
{
myIR_cmdStrParser(strTemp);//toggle not used for nec
return;
}
//assume append to file, check label no empty
if(label.IsEmpty()) {myMesShow(_T("- error, need label !")); return;}
myIR_appendToFileOrCreate(strTemp, "NEC.irp");//toggle not used for nec

}// end NEC_cmd_create

void IR_constructor::RC5_cmd_create(BYTE irAddress, BYTE irCommand, CString label, bool useTestSend)//create 2 commands for toggle!
{
// for toggle add 0,1 to end of label
CString strTemp = _T("carrier=36000 pulses=32 duty=4 label=");
label.TrimRight();
strTemp += label;
//shortest uses bit-time 1.778mkS = 64 cycles of 36kHz = min lenght 32 pulses !
//total lenght = 14 bit, use byte-pack... 28 bit of string
UINT bitCmdFromMost0 = 0x58000000;//0b010110 00 000000000000000000000000 - use toggle bit
UINT bitCmdFromMost1 = 0x54000000;//0b010101 00 000000000000000000000000
if((irCommand & 0x40) != 0)//7bit used, inverted
{
bitCmdFromMost0 = 0x68000000;//0b011010 00000000000000000000000000 - use toggle bit
bitCmdFromMost1 = 0x64000000;//0b011001 0000000000 0000000000000000
}

//set address... (5 bit)
UINT bitCounter = 0;
UINT tempMask = 0;
while(bitCounter++ < 5)
{
tempMask <<= 2;
if((irAddress & 0x10) != 0) tempMask |= 1;
else tempMask |= 2;
irAddress <<= 1;
}
//10 bit in mask!!
tempMask <<= 16;
bitCmdFromMost0 |= tempMask;
bitCmdFromMost1 |= tempMask;
//set command... (6 bit)
bitCounter = 0;
tempMask = 0;
while(bitCounter++ < 6)
{
tempMask <<= 2;
if((irCommand & 0x20) != 0) tempMask |= 1;
else tempMask |= 2;
irCommand <<= 1;
}
//12 bit in mask!!
tempMask <<= 4;
bitCmdFromMost0 |= tempMask;
bitCmdFromMost1 |= tempMask;
//command ready, 4 bytes to send
CString strTemp2;
strTemp2.Format( "#0 00%.8X\r\n", bitCmdFromMost0);
CString strCmd0 = strTemp + strTemp2;
strTemp2.Format( "#1 00%.8X\r\n", bitCmdFromMost1);
CString strCmd1 = strTemp + strTemp2;
//can send (but toggle)
if(useTestSend)
{
if(0 == curTogglePosition) {myIR_cmdStrParser(strCmd0); curTogglePosition = 1;}
else {myIR_cmdStrParser(strCmd1); curTogglePosition = 0;}
return;
}
//assume append to file, check label no empty
if(label.IsEmpty()) {myMesShow(_T("- error, need label !")); return;}
myIR_appendToFileOrCreate(strCmd0, "RC5.irp");//first
myIR_appendToFileOrCreate(strCmd1, "RC5.irp");//second (for toggle)
}// end RC5_cmd_create

void IR_constructor::RC6_cmd_create(BYTE irMode, BYTE irAddress, BYTE irCommand, CString label, bool useTestSend)//create 2 commands for toggle!
{
// for toggle add 0,1 to end of label
CString strTemp = _T("carrier=36000 pulses=16 duty=4 label=");
label.TrimRight();
strTemp += label;
//shortest uses bit-time  = 32 cycles of 36kHz = min lenght 16 pulses !
//total lenght = 14 bit, use byte-pack... 28 bit of string
//RC6 coded 0 and 1 opposite of RC5!!!
UINT bitCmdFromMost0 = 0xFC803000;//0b11111100 10 00 00 00 0011 000000000000 - use toggle bit
UINT bitCmdFromMost1 = 0xFC80C000;//0b11111100 10 00 00 00 1100 000000000000
//set mode (3bits, usually 0)
UINT bitCounter = 0;
UINT tempMask = 0;
while(bitCounter++ < 3)
{
tempMask <<= 2;
if((irMode & 0x04) != 0) tempMask |= 2;//opposite to RC5!!!
else tempMask |= 1;//opposite to RC5!!!
irMode <<= 1;
}
//6 bit in mask!!
tempMask <<= 16;
bitCmdFromMost0 |= tempMask;
bitCmdFromMost1 |= tempMask;
//set control bits (8 BITS)
bitCounter = 0;
tempMask = 0;
while(bitCounter++ < 8)
{
tempMask <<= 2;
if((irAddress & 0x80) != 0) tempMask |= 2;//opposite to RC5!!!
else tempMask |= 1;//opposite to RC5!!!
irAddress <<= 1;
}
//16 bit in mask!! buy only 12 bits tail of uint
bitCmdFromMost0 |= (tempMask >> 4);
bitCmdFromMost1 |= (tempMask >> 4);
//use next uint!
UINT bitCmdFromMost0_1 = 0;//trail will be equal for toggled
//apply last 4 bit to most ...
bitCmdFromMost0_1 |= (tempMask << 28);
//set information bits (8 BITS)
bitCounter = 0;
tempMask = 0;
while(bitCounter++ < 8)
{
tempMask <<= 2;
if((irCommand & 0x80) != 0) tempMask |= 2;//opposite to RC5!!!
else tempMask |= 1;//opposite to RC5!!!
irCommand <<= 1;
}
//16 bit in mask!!
//apply after first 4 bit to most ...
bitCmdFromMost0_1 |= (tempMask << 12);
//pause 6t, but unused trail = 12t for uint - good
//command ready, 8 bytes to send
CString strTemp2;
strTemp2.Format( "#0 00%.8X%.8X\r\n", bitCmdFromMost0, bitCmdFromMost0_1);
CString strCmd0 = strTemp + strTemp2;
strTemp2.Format( "#1 00%.8X%.8X\r\n", bitCmdFromMost1, bitCmdFromMost0_1);
CString strCmd1 = strTemp + strTemp2;
//can send (but toggle)
if(useTestSend)
{
if(0 == curTogglePosition) {myIR_cmdStrParser(strCmd0); curTogglePosition = 1;}
else {myIR_cmdStrParser(strCmd1); curTogglePosition = 0;}
return;
}
//assume append to file, check label no empty
if(label.IsEmpty()) {myMesShow(_T("- error, need label !")); return;}
myIR_appendToFileOrCreate(strCmd0, "RC6.irp");//first
myIR_appendToFileOrCreate(strCmd1, "RC6.irp");//second (for toggle)

}// end RC6_cmd_create

void IR_constructor::RCMM_cmd_create(BYTE irMode, BYTE irAddress, UINT irCommand, bool useExtended, CString label, bool useTestSend)//create 2 commands for toggle!
{
// toggle NOT USED. PROTOCOL HAS SPECIAL CODING!!! TRY 1 PULSE PER BIT!
CString strTemp = _T("carrier=36000 pulses=1 duty=4 label=");
label.TrimRight();
strTemp += label;
//shortest uses bit-time  = 1 cycle of 36kHz = min lenght 1 pulse, CANNOT ROUND !
//Each message is preceded by a header pulse with the duration of 416.7 µs (15 pulses of the carrier),
// followed by a space of 277.8 µs (10 periods of the carrier).
// This header is followed by 12 or 24 bits of data. 
//total lenght = 12 OR 24 bits DATA
//Data Mark Space 
//0 0 166.7 µs (6 cycles) 277.8 µs (10 cycles) 
//0 1 166.7 µs (6 cycles) 444.4 µs (16 cycles) 
//1 0 166.7 µs (6 cycles) 611.1 µs (22 cycles) 
//1 1 166.7 µs (6 cycles) 777.8 µs (28 cycles) 
//All data is sent with MSB first. 
//SETUP START...
resetBitArray();
bitArray[0] = 0xFF;
bitArray[1] = 0xFE;//15 of 1, 1 of 0 + next 9 of 0
bytePointer = 3;
bitPointer = 1;//point to start of data.
if(useExtended) RCMM_cmd_2bitAdd((irMode >> 2));//assume mode is 4 bit, load most from var...
RCMM_cmd_2bitAdd(irMode);//add 2 low bits for var
if(useExtended)
{
if(0 == (irMode & 0x0F))//oem mode!
{
RCMM_cmd_2bitAdd(0x03);//add 2 low bits as 11 for oem mode, use next 6 bits...
RCMM_cmd_2bitAdd((irAddress >> 4));
RCMM_cmd_2bitAdd((irAddress >> 2));
RCMM_cmd_2bitAdd(irAddress);//irAddress used as customer ID
//now 12 bits payload data...
RCMM_cmd_2bitAdd((irCommand >> 10));
RCMM_cmd_2bitAdd((irCommand >> 8));
RCMM_cmd_2bitAdd((irCommand >> 6));
RCMM_cmd_2bitAdd((irCommand >> 4));
RCMM_cmd_2bitAdd((irCommand >> 2));
RCMM_cmd_2bitAdd(irCommand);
}
else//if not oem, use payload data full 20bit
{
RCMM_cmd_2bitAdd((irCommand >> 18));
RCMM_cmd_2bitAdd((irCommand >> 16));
RCMM_cmd_2bitAdd((irCommand >> 14));
RCMM_cmd_2bitAdd((irCommand >> 12));
RCMM_cmd_2bitAdd((irCommand >> 10));
RCMM_cmd_2bitAdd((irCommand >> 8));
RCMM_cmd_2bitAdd((irCommand >> 6));
RCMM_cmd_2bitAdd((irCommand >> 4));
RCMM_cmd_2bitAdd((irCommand >> 2));
RCMM_cmd_2bitAdd(irCommand);
}
}
else//not extended ...
{
//2bit address ...
RCMM_cmd_2bitAdd(irAddress);//irAddress 2 bits only
//8 bit payload data
RCMM_cmd_2bitAdd((irCommand >> 6));
RCMM_cmd_2bitAdd((irCommand >> 4));
RCMM_cmd_2bitAdd((irCommand >> 2));
RCMM_cmd_2bitAdd(irCommand);
}

//all RCMM loaded, convert to string...
strTemp += _T(" 00");//set transmission bytes start 00
CString strTemp2;
UINT tmpCounter = 0;
while(tmpCounter <= bytePointer)
{
strTemp2.Format( "%.2X", bitArray[tmpCounter]);
strTemp += strTemp2;
tmpCounter++;
}

strTemp += _T("00\r\n");//set transmission bytes end
//can send (but toggle)
if(useTestSend)
{
myIR_cmdStrParser(strTemp);//toggle not used for nec
return;
}
//assume append to file, check label no empty
if(label.IsEmpty()) {myMesShow(_T("- error, need label !")); return;}
myIR_appendToFileOrCreate(strTemp, "RCMM.irp");//toggle not used for RCMM

}// end RCMM_cmd_create