DashyFox/IR-protocol
1
0
Fork 0
mirror of https://github.com/Show-maket/IR-protocol.git synced 2025-06-27 20:59:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

MultiGen isr

Browse Source
This commit is contained in:
DashyFox
2024-02-06 17:14:59 +03:00
parent 02410cc78c
commit e0fbc8502d
3 changed files with 148 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
IR_Encoder.cpp
View File

@ -3,12 +3,18 @@
IR_Encoder::IR_Encoder(uint16_t addr, uint8_t pin, uint8_t tune = 0, IR_Decoder* decPair) {
ir_out = pin;
pinMode(ir_out, OUTPUT);
addrSelf = addr;
decoder = decPair;
carrierTune = tune;
halfPeriod = (carrierPeriod / 2) - carrierTune;
dataBitCounter = 0 - preambFronts;
signal = noSignal;
};
IR_Encoder::~IR_Encoder() {};
void IR_Encoder::sendACK(uint16_t addrTo, uint8_t addInfo, bool forAll = false) {
@ -102,34 +108,105 @@ void IR_Encoder::_sendData(uint16_t addrTo, uint8_t* data, uint8_t len, uint8_t
}
void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
/*tmp*/bool LOW_FIRST = false;/*tmp*/
digitalToggle(9); digitalToggle(9);
isSending = true;
if (decoder != nullptr) { decoder->isPairSending = isSending; }
cli();
// toggleCounter = bitTakts*2 - 1;
#define preambToggle ((bitPauseTakts * 2 + bitActiveTakts) * 2 - 1)
// #define preambToggle (3*2-1)
toggleCounter = preambToggle;
preambBitCounter = preambPulse;
dataBitCounter = 0;
syncBitCounter = 0;
if (decoder != nullptr) { decoder->isPairSending = true; }
signal = preamb;
isSending = true;
state = HIGH;
sei();
}
bool prev = 1;
bool next;
send_EMPTY(preambPulse); // преамбула
for (uint16_t byteNum = 0; byteNum < len; byteNum++) {
sendByte(ptr[byteNum], &prev, LOW_FIRST);
if (byteNum < len - 1) {
next = ptr[byteNum + 1] & (LOW_FIRST ? 0b00000001 : 0b10000000);
} else {
next = 0;
void IR_Encoder::isr() {
if (!isSending) return;
ir_out_virtual = !ir_out_virtual && state;
if (!toggleCounter) {
state = !state;
switch (signal) {
case noSignal:
return;
break;
case preamb:
toggleCounter = preambToggle;
if (!state) { // Низкий уровень - конец периода генерации
preambBitCounter--;
if (!preambBitCounter) { // Конец преамбулы, переход на следующий этап
isSending = false;
}
}
break;
case data:
signal = (SignalPart)(~signal); // 2 -> 253, 253 -> 2
break;
case sync:
signal = (SignalPart)(~signal); // 2 -> 253, 253 -> 2
break;
default:
return;
break;
}
addSync(&prev, &next);
}
if (decoder != nullptr) { decoder->isPairSending = false; }
} else { toggleCounter--; }
}
void old() {///////////////////////////////////////////////////////
// void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
// /*tmp*/bool LOW_FIRST = false;/*tmp*/
// if (decoder != nullptr) { decoder->isPairSending = true; }
// bool prev = 1;
// bool next;
// send_EMPTY(preambPulse); // преамбула
// for (uint16_t byteNum = 0; byteNum < len; byteNum++) {
// sendByte(ptr[byteNum], &prev, LOW_FIRST);
// if (byteNum < len - 1) {
// next = ptr[byteNum + 1] & (LOW_FIRST ? 0b00000001 : 0b10000000);
// } else {
// next = 0;
// }
// addSync(&prev, &next);
// }
// if (decoder != nullptr) { decoder->isPairSending = false; }
// }
}
void IR_Encoder::sendByte(uint8_t byte, bool* prev, bool LOW_FIRST) {
uint8_t mask = LOW_FIRST ? 0b00000001 : 0b10000000;
for (uint8_t bitShift = 8; bitShift; bitShift--) {
digitalWrite(9, HIGH);
digitalWrite(9, LOW);
byte& mask ? send_HIGH(prev) : send_LOW();
*prev = byte & mask;
LOW_FIRST ? mask <<= 1 : mask >>= 1;
digitalWrite(9, HIGH);
digitalWrite(9, LOW);
}
}
@ -152,39 +229,29 @@ void IR_Encoder::addSync(bool* prev, bool* next) {
}
void IR_Encoder::send_HIGH(bool prevBite = 1) {
if (prevBite) {
meanderBlock(bitPauseTakts * 2, halfPeriod, LOW);
meanderBlock(bitActiveTakts, halfPeriod, HIGH);
} else { // более короткий HIGH после нуля
meanderBlock(bitTakts - (bitActiveTakts - bitPauseTakts), halfPeriod, LOW);
meanderBlock(bitActiveTakts - bitPauseTakts, halfPeriod, HIGH);
}
// if (/* prevBite */1) {
// meanderBlock(bitPauseTakts * 2, halfPeriod, LOW);
// meanderBlock(bitActiveTakts, halfPeriod, HIGH);
// } else { // более короткий HIGH после нуля
// meanderBlock(bitTakts - (bitActiveTakts - bitPauseTakts), halfPeriod, LOW);
// meanderBlock(bitActiveTakts - bitPauseTakts, halfPeriod, HIGH);
// }
}
void IR_Encoder::send_LOW() {
meanderBlock(bitPauseTakts, halfPeriod, LOW);
meanderBlock(bitActiveTakts, halfPeriod, LOW);
meanderBlock(bitPauseTakts, halfPeriod, HIGH);
// meanderBlock(bitPauseTakts, halfPeriod, LOW);
// meanderBlock(bitActiveTakts, halfPeriod, LOW);
// meanderBlock(bitPauseTakts, halfPeriod, HIGH);
}
void IR_Encoder::send_EMPTY(uint8_t count) {
for (size_t i = 0; i < count * 2; i++) {
meanderBlock(bitPauseTakts * 2 + bitActiveTakts, halfPeriod, prevPreambBit);
prevPreambBit = !prevPreambBit;
}
// for (size_t i = 0; i < count * 2; i++) {
// meanderBlock((bitPauseTakts * 2 + bitActiveTakts), halfPeriod, prevPreambBit);
// prevPreambBit = !prevPreambBit;
// }
// meanderBlock(bitPauseTakts * 2 + bitActiveTakts, halfPeriod, 0); //TODO: Отодвинуть преамбулу
}
void IR_Encoder::meanderBlock(uint16_t count, uint16_t _period, bool high = true) {
for (uint16_t i = 0; i < count << 1; i++) {
if ((i & 1)) { // Если чётное
//PORTC &= ~(1 << 3); // LOW
digitalWrite(ir_out, high ? LOW : LOW);
} else { // Если не четное
//PORTC |= 1 << 3; // HIGH
digitalWrite(ir_out, high ? HIGH : LOW);
}
delayMicroseconds(_period);
}
}