902 lines
25 KiB
C++
902 lines
25 KiB
C++
#include "Oregon_TM.h"
|
||
|
||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// This file is part of the Arduino OREGON_NR library.
|
||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
//
|
||
// The MIT License (MIT)
|
||
//
|
||
// Copyright (c) 2021 Sergey Zawislak
|
||
//
|
||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
|
||
// to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||
// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||
//
|
||
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||
//
|
||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||
// IN THE SOFTWARE.
|
||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// Этот файл - часть библиотеки OREGON_NR
|
||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
//
|
||
// Copyright (c) 2021 Сергей Зависляк
|
||
//
|
||
// Данная лицензия разрешает лицам, получившим копию данного программного обеспечения и сопутствующей документации
|
||
// (в дальнейшем именуемыми «Программное Обеспечение»), безвозмездно использовать Программное Обеспечение без ограничений,
|
||
// включая неограниченное право на использование, копирование, изменение, слияние, публикацию, распространение, сублицензирование
|
||
// и/или продажу копий Программного Обеспечения, а также лицам, которым предоставляется данное Программное Обеспечение, при соблюдении следующих условий:
|
||
//
|
||
// Указанное выше уведомление об авторском праве и данные условия должны быть включены во все копии или значимые части данного Программного Обеспечения.
|
||
//
|
||
// ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||
// ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ
|
||
// НЕ НЕСУТ ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА УЩЕРБ ИЛИ ПО ИНЫМ ТРЕБОВАНИЯМ, В ТОМ ЧИСЛЕ, ПРИ ДЕЙСТВИИ КОНТРАКТА, ДЕЛИКТЕ ИЛИ ИНОЙ СИТУАЦИИ,
|
||
// ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
|
||
|
||
//Конструктор
|
||
|
||
Oregon_TM::Oregon_TM(byte tr_pin, int buf_size)
|
||
{
|
||
max_buffer_size = (int)(buf_size / 2) + 2;
|
||
SendBuffer = new byte[max_buffer_size + 2];
|
||
TX_PIN = tr_pin;
|
||
pinMode(TX_PIN, OUTPUT);
|
||
digitalWrite(TX_PIN, LOW);
|
||
|
||
}
|
||
|
||
Oregon_TM::Oregon_TM(byte tr_pin)
|
||
{
|
||
SendBuffer = new byte[max_buffer_size + 2];
|
||
TX_PIN = tr_pin;
|
||
pinMode(TX_PIN, OUTPUT);
|
||
digitalWrite(TX_PIN, LOW);
|
||
|
||
}
|
||
|
||
Oregon_TM::Oregon_TM(void)
|
||
{
|
||
SendBuffer = new byte[max_buffer_size + 2];
|
||
pinMode(TX_PIN, OUTPUT);
|
||
digitalWrite(TX_PIN, LOW);
|
||
}
|
||
|
||
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// Функции передатчика////////////////////////////////////////////////////////////////////////////
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
void Oregon_TM::sendZero(void)
|
||
{
|
||
if (protocol == 2) {
|
||
while (time_marker + TR_TIME * 4 >= micros());
|
||
time_marker += TR_TIME * 4;
|
||
digitalWrite(TX_PIN, HIGH);
|
||
delayMicroseconds(TR_TIME - PULSE_SHORTEN_2);
|
||
digitalWrite(TX_PIN, LOW);
|
||
delayMicroseconds(TWOTR_TIME + PULSE_SHORTEN_2);
|
||
digitalWrite(TX_PIN, HIGH);
|
||
}
|
||
if (protocol == 3)
|
||
{
|
||
if (prevstate) while (time_marker + TWOTR_TIME - PULSE_SHORTEN_3 >= micros());
|
||
else while (time_marker + TWOTR_TIME >= micros());
|
||
|
||
time_marker += TWOTR_TIME;
|
||
|
||
if (prevbit && prevstate)
|
||
{
|
||
digitalWrite(TX_PIN, LOW);
|
||
prevstate = 0;
|
||
prevbit = 0;
|
||
return;
|
||
}
|
||
if (prevbit && !prevstate)
|
||
{
|
||
digitalWrite(TX_PIN, HIGH);
|
||
delayMicroseconds(TWOTR_TIME);
|
||
prevstate = 1;
|
||
prevbit = 0;
|
||
return;
|
||
}
|
||
if (!prevbit && prevstate)
|
||
{
|
||
digitalWrite(TX_PIN, LOW);
|
||
delayMicroseconds(TR_TIME);
|
||
digitalWrite(TX_PIN, HIGH);
|
||
prevbit = 0;
|
||
return;
|
||
}
|
||
if (!prevbit && !prevstate)
|
||
{
|
||
digitalWrite(TX_PIN, HIGH);
|
||
delayMicroseconds(TR_TIME);
|
||
digitalWrite(TX_PIN, LOW);
|
||
prevbit = 0;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::sendOne(void)
|
||
{
|
||
if (protocol == 2) {
|
||
while (time_marker + TR_TIME * 4 - PULSE_SHORTEN_2 >= micros());
|
||
time_marker += TR_TIME * 4;
|
||
digitalWrite(TX_PIN, LOW);
|
||
delayMicroseconds(TR_TIME + PULSE_SHORTEN_2);
|
||
digitalWrite(TX_PIN, HIGH);
|
||
delayMicroseconds(TWOTR_TIME - PULSE_SHORTEN_2);
|
||
digitalWrite(TX_PIN, LOW);
|
||
}
|
||
|
||
if (protocol == 3)
|
||
{
|
||
if (prevstate) while (time_marker + TWOTR_TIME - PULSE_SHORTEN_3 >= micros());
|
||
else while (time_marker + TWOTR_TIME >= micros());
|
||
time_marker += TWOTR_TIME;
|
||
|
||
if (!prevbit && prevstate)
|
||
{
|
||
digitalWrite(TX_PIN, LOW);
|
||
prevstate = 0;
|
||
prevbit = 1;
|
||
return;
|
||
}
|
||
if (!prevbit && !prevstate)
|
||
{
|
||
digitalWrite(TX_PIN, HIGH);
|
||
prevstate = 1;
|
||
prevbit = 1;
|
||
return;
|
||
}
|
||
if (prevbit && prevstate)
|
||
{
|
||
digitalWrite(TX_PIN, LOW);
|
||
delayMicroseconds(TR_TIME);
|
||
digitalWrite(TX_PIN, HIGH);
|
||
prevbit = 1;
|
||
return;
|
||
}
|
||
if (prevbit && !prevstate)
|
||
{
|
||
digitalWrite(TX_PIN, HIGH);
|
||
delayMicroseconds(TR_TIME);
|
||
digitalWrite(TX_PIN, LOW);
|
||
prevbit = 1;
|
||
return;
|
||
}
|
||
|
||
}
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::sendMSB(byte data)
|
||
{
|
||
(bitRead(data, 4)) ? sendOne() : sendZero();
|
||
(bitRead(data, 5)) ? sendOne() : sendZero();
|
||
(bitRead(data, 6)) ? sendOne() : sendZero();
|
||
(bitRead(data, 7)) ? sendOne() : sendZero();
|
||
if (protocol == 2) time_marker += timing_corrector2; //Поправка на разницу тактовых частот 1024.07Гц и 1024.60Гц
|
||
if (protocol == 3) time_marker += timing_corrector3;
|
||
|
||
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::sendLSB(byte data)
|
||
{
|
||
(bitRead(data, 0)) ? sendOne() : sendZero();
|
||
(bitRead(data, 1)) ? sendOne() : sendZero();
|
||
(bitRead(data, 2)) ? sendOne() : sendZero();
|
||
(bitRead(data, 3)) ? sendOne() : sendZero();
|
||
if (protocol == 2) time_marker += timing_corrector2; //Поправка на разницу тактовых частот 1024.07Гц и 1024.60Гц
|
||
if (protocol == 3) time_marker += timing_corrector3;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::sendData()
|
||
{
|
||
int q = 0;
|
||
for (byte i = 0; i < max_buffer_size; i++)
|
||
{
|
||
sendMSB(SendBuffer[i]);
|
||
q++;
|
||
if (q >= buffer_size) break;
|
||
sendLSB(SendBuffer[i]);
|
||
q++;
|
||
if (q >= buffer_size) break;
|
||
if (protocol == 2) time_marker += 4; //Поправка на разницу тактовых частот 1024.07Гц и 1024.60Гц
|
||
//if (protocol == 3) time_marker += 4;
|
||
//Поправка на разницу тактовых частот 1024.07Гц и 1024Гц
|
||
}
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::sendOregon()
|
||
{
|
||
time_marker = micros();
|
||
sendPreamble();
|
||
sendLSB(0xA);
|
||
sendData();
|
||
sendZero();
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::sendPreamble(void)
|
||
{
|
||
if (protocol == 2) {
|
||
sendLSB(0xF);
|
||
sendLSB(0xF);
|
||
time_marker += 9;
|
||
sendLSB(0xF);
|
||
sendLSB(0xF);
|
||
time_marker += 9;
|
||
}
|
||
if (protocol == 3) {
|
||
sendLSB(0xF);
|
||
sendLSB(0xF);
|
||
sendLSB(0xF);
|
||
sendLSB(0xF);
|
||
time_marker += 4;
|
||
sendLSB(0xF);
|
||
sendLSB(0xF);
|
||
time_marker += 3;
|
||
}
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::calculateAndSetChecksum129(void)
|
||
{
|
||
byte CCIT_POLY = 0x07;
|
||
SendBuffer[9] &= 0xF0;
|
||
SendBuffer[10] = 0x00;
|
||
SendBuffer[11] = 0x00;
|
||
byte summ = 0x00;
|
||
byte crc = 0x00;
|
||
byte cur_nible;
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
cur_nible = (SendBuffer[i] & 0xF0) >> 4;
|
||
summ += cur_nible;
|
||
if (i != 3)
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
cur_nible = SendBuffer[i] & 0x0F;
|
||
summ += cur_nible;
|
||
if (i != 2)
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
}
|
||
SendBuffer[9] += summ & 0x0F;
|
||
SendBuffer[10] += summ & 0xF0;
|
||
SendBuffer[10] += crc & 0x0F;
|
||
SendBuffer[11] += crc & 0xF0;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::calculateAndSetChecksum968(void)
|
||
{
|
||
byte CCIT_POLY = 0x07;
|
||
SendBuffer[9] &= 0xF0;
|
||
SendBuffer[10] = 0x00;
|
||
SendBuffer[11] = 0x00;
|
||
byte summ = 0x00;
|
||
byte crc = 0xA1;
|
||
byte cur_nible;
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
cur_nible = (SendBuffer[i] & 0xF0) >> 4;
|
||
summ += cur_nible;
|
||
if (i != 3)
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
cur_nible = SendBuffer[i] & 0x0F;
|
||
summ += cur_nible;
|
||
if (i != 2)
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
}
|
||
SendBuffer[9] += summ & 0x0F;
|
||
SendBuffer[10] += summ & 0xF0;
|
||
SendBuffer[10] += crc & 0x0F;
|
||
SendBuffer[11] += crc & 0xF0;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::calculateAndSetChecksum132(void)
|
||
{
|
||
byte CCIT_POLY = 0x07;
|
||
SendBuffer[7] &= 0xF0;
|
||
SendBuffer[8] = 0x00;
|
||
SendBuffer[9] = 0x00;
|
||
byte summ = 0x00;
|
||
byte crc = 0x3C;
|
||
byte cur_nible;
|
||
for (int i = 0; i < 8; i++)
|
||
{
|
||
cur_nible = (SendBuffer[i] & 0xF0) >> 4;
|
||
summ += cur_nible;
|
||
if (i != 3)
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
cur_nible = SendBuffer[i] & 0x0F;
|
||
summ += cur_nible;
|
||
if (i != 2)
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
}
|
||
SendBuffer[7] += summ & 0x0F;
|
||
SendBuffer[8] += summ & 0xF0;
|
||
SendBuffer[8] += crc & 0x0F;
|
||
SendBuffer[9] += crc & 0xF0;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::calculateAndSetChecksum132S(void)
|
||
{
|
||
byte CCIT_POLY = 0x07;
|
||
byte summ = 0x00;
|
||
byte crc = 0xD6;
|
||
SendBuffer[6] = SendBuffer[7] = 0x00;
|
||
byte cur_nible;
|
||
for (int i = 0; i < 6; i++)
|
||
{
|
||
cur_nible = (SendBuffer[i] & 0xF0) >> 4;
|
||
summ += cur_nible;
|
||
if (i != 3)
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
cur_nible = SendBuffer[i] & 0x0F;
|
||
summ += cur_nible;
|
||
if (i != 2)
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
}
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
|
||
SendBuffer[6] += (summ & 0x0F) << 4;
|
||
SendBuffer[6] += (summ & 0xF0) >> 4;
|
||
SendBuffer[7] += (crc & 0x0F) << 4;
|
||
SendBuffer[7] += (crc & 0xF0) >> 4;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::calculateAndSetChecksum318()
|
||
{
|
||
byte CCIT_POLY = 0x07;
|
||
SendBuffer[7] = SendBuffer[7] & 0xF0;
|
||
SendBuffer[8] = 0x00;
|
||
SendBuffer[9] = 0x00;
|
||
byte summ = 0x00;
|
||
byte crc = 0x00;
|
||
byte cur_nible;
|
||
for (int i = 0; i < 8; i++)
|
||
{
|
||
cur_nible = (SendBuffer[i] & 0xF0) >> 4;
|
||
summ += cur_nible;
|
||
if (i != 3)
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
cur_nible = SendBuffer[i] & 0x0F;
|
||
summ += cur_nible;
|
||
if (i != 2)
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
}
|
||
SendBuffer[7] += summ & 0x0F;
|
||
SendBuffer[8] += summ & 0xF0;
|
||
SendBuffer[8] += crc & 0x0F;
|
||
SendBuffer[9] += crc & 0xF0;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::calculateAndSetChecksum810()
|
||
{
|
||
byte CCIT_POLY = 0x07;
|
||
SendBuffer[7] = SendBuffer[7] & 0xF0;
|
||
SendBuffer[8] = 0x00;
|
||
SendBuffer[9] = 0x00;
|
||
byte summ = 0x00;
|
||
byte crc = 0x00;
|
||
byte cur_nible;
|
||
for (int i = 0; i < 8; i++)
|
||
{
|
||
cur_nible = (SendBuffer[i] & 0xF0) >> 4;
|
||
summ += cur_nible;
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
cur_nible = SendBuffer[i] & 0x0F;
|
||
summ += cur_nible;
|
||
{
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
}
|
||
SendBuffer[7] += summ & 0x0F;
|
||
SendBuffer[8] += summ & 0xF0;
|
||
SendBuffer[8] += crc & 0x0F;
|
||
SendBuffer[9] += crc & 0xF0;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::SendPacket()
|
||
{
|
||
if (sens_type == BTHR968)
|
||
calculateAndSetChecksum968();
|
||
if (sens_type == BTHGN129)
|
||
calculateAndSetChecksum129();
|
||
if (sens_type == THGN132)
|
||
calculateAndSetChecksum132();
|
||
if (sens_type == THN132)
|
||
calculateAndSetChecksum132S();
|
||
if (sens_type == RTGN318)
|
||
calculateAndSetChecksum318();
|
||
if (sens_type == THGR810)
|
||
calculateAndSetChecksum810();
|
||
if (sens_type == THP)
|
||
calculateAndSetChecksumTHP();
|
||
|
||
sendOregon();
|
||
digitalWrite(TX_PIN, LOW);
|
||
if (protocol == 2) {
|
||
delayMicroseconds(TWOTR_TIME * 15);
|
||
sendOregon();
|
||
digitalWrite(TX_PIN, LOW);
|
||
}
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// Функции кодирования данных//////////////////////////////////////////////////////////////////////
|
||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||
void Oregon_TM::setType(word type)
|
||
{
|
||
sens_type = type;
|
||
if (type == THP)
|
||
{
|
||
SendBuffer[0] = 0x55;
|
||
return;
|
||
}
|
||
SendBuffer[0] = (type & 0xFF00) >> 8;
|
||
SendBuffer[1] = type & 0x00FF;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::setChannel(byte channel)
|
||
{
|
||
byte channel_code;
|
||
|
||
if (sens_type == BTHR968)
|
||
{
|
||
channel_code = 0x00;
|
||
setId(0xF0);
|
||
send_time = 40000;
|
||
}
|
||
|
||
if (sens_type == THGN132)
|
||
{
|
||
if (channel <= 1)
|
||
{
|
||
channel_code = 0x10;
|
||
setId(0xE3);
|
||
send_time = 39000;
|
||
}
|
||
if (channel == 2)
|
||
{
|
||
channel_code = 0x20;
|
||
setId(0xE3);
|
||
send_time = 41000;
|
||
}
|
||
if (channel == 3)
|
||
{
|
||
channel_code = 0x40;
|
||
setId(0xBB);
|
||
send_time = 43000;
|
||
}
|
||
protocol = 2;
|
||
}
|
||
|
||
if (sens_type == THN132)
|
||
{
|
||
if (channel <= 1)
|
||
{
|
||
channel_code = 0x10;
|
||
setId(0xE3);
|
||
send_time = 39000;
|
||
}
|
||
if (channel == 2)
|
||
{
|
||
channel_code = 0x20;
|
||
setId(0xE3);
|
||
send_time = 41000;
|
||
}
|
||
if (channel == 3)
|
||
{
|
||
channel_code = 0x40;
|
||
setId(0xBB);
|
||
send_time = 43000;
|
||
}
|
||
protocol = 2;
|
||
}
|
||
|
||
|
||
if (sens_type == RTGN318 || sens_type == BTHGN129)
|
||
{
|
||
|
||
if (channel <= 1)
|
||
{
|
||
channel_code = 0x10;
|
||
setId(0xF1);
|
||
send_time = 53000;
|
||
}
|
||
if (channel == 2)
|
||
{
|
||
channel_code = 0x20;
|
||
setId(0x92);
|
||
send_time = 59000;
|
||
}
|
||
if (channel == 3)
|
||
{
|
||
channel_code = 0x30;
|
||
setId(0xAA);
|
||
send_time = 61000;
|
||
}
|
||
|
||
if (channel == 4)
|
||
{
|
||
channel_code = 0x40;
|
||
setId(0x8A);
|
||
send_time = 67000;
|
||
}
|
||
|
||
if (channel >= 5)
|
||
{
|
||
channel_code = 0x50;
|
||
setId(0xB1);
|
||
send_time = 71000;
|
||
}
|
||
protocol = 2;
|
||
}
|
||
|
||
if (sens_type == THGR810)
|
||
{
|
||
if (channel <= 1)
|
||
{
|
||
channel_code = 0x10;
|
||
setId(0xCB);
|
||
send_time = 53000;
|
||
}
|
||
if (channel == 2)
|
||
{
|
||
channel_code = 0x20;
|
||
setId(0x69);
|
||
send_time = 59000;
|
||
}
|
||
if (channel == 3)
|
||
{
|
||
channel_code = 0x30;
|
||
setId(0xAA);
|
||
send_time = 61000;
|
||
}
|
||
if (channel == 4)
|
||
{
|
||
channel_code = 0x40;
|
||
setId(0x8A);
|
||
send_time = 67000;
|
||
}
|
||
if (channel == 5)
|
||
{
|
||
channel_code = 0x50;
|
||
setId(0xB1);
|
||
send_time = 71000;
|
||
}
|
||
if (channel == 6)
|
||
{
|
||
channel_code = 0x60;
|
||
send_time = 79000;
|
||
}
|
||
if (channel == 7)
|
||
{
|
||
channel_code = 0x70;
|
||
send_time = 83000;
|
||
}
|
||
if (channel == 8)
|
||
{
|
||
channel_code = 0x80;
|
||
send_time = 87000;
|
||
}
|
||
if (channel == 9)
|
||
{
|
||
channel_code = 0x90;
|
||
send_time = 91000;
|
||
}
|
||
if (channel >= 10)
|
||
{
|
||
channel_code = 0xA0;
|
||
send_time = 93000;
|
||
}
|
||
protocol = 3;
|
||
}
|
||
SendBuffer[2] &= 0x0F;
|
||
SendBuffer[2] += channel_code & 0xF0;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::setId(byte ID)
|
||
{
|
||
SendBuffer[2] &= 0xF0;
|
||
SendBuffer[2] += (ID & 0xF0) >> 4;
|
||
SendBuffer[3] &= 0x0F;
|
||
SendBuffer[3] += (ID & 0x0F) << 4;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::setBatteryFlag(bool level)
|
||
{
|
||
SendBuffer[3] &= 0xFB;
|
||
if (level) SendBuffer[3] |= 0x04;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::setStartCount(byte startcount)
|
||
{
|
||
SendBuffer[3] &= 0xF4;
|
||
if (startcount == 8) SendBuffer[3] |= 0x08;
|
||
if (startcount == 2) SendBuffer[3] |= 0x02;
|
||
if (startcount == 1) SendBuffer[3] |= 0x01;
|
||
}
|
||
|
||
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::setPressure(float mm_hg_pressure)
|
||
{
|
||
//Ограничения датчика по даташиту
|
||
word pressure = (word)(mm_hg_pressure / 0.75);
|
||
if (mm_hg_pressure < 450) pressure = 600;
|
||
if (mm_hg_pressure > 790) pressure = 1054;
|
||
|
||
if (sens_type == BTHR968)
|
||
{
|
||
pressure -= 600;
|
||
SendBuffer[7] &= 0xF0;
|
||
SendBuffer[7] += pressure & 0x0F;
|
||
SendBuffer[8] = (pressure & 0x0F0) + ((pressure & 0xF00) >> 8);
|
||
//прогноз - переменно
|
||
SendBuffer[9] &= 0x0F;
|
||
SendBuffer[9] += 0x60;
|
||
}
|
||
|
||
if (sens_type == BTHGN129)
|
||
{
|
||
pressure -= 545;
|
||
SendBuffer[7] &= 0xF0;
|
||
SendBuffer[7] += pressure & 0x0F;
|
||
SendBuffer[8] = (pressure & 0x0F0) + ((pressure & 0xF00) >> 8);
|
||
SendBuffer[9] &= 0x0F;
|
||
SendBuffer[9] += 0x60;
|
||
}
|
||
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
void Oregon_TM::setTemperature(float temp)
|
||
{
|
||
if (temp < 0)
|
||
{
|
||
SendBuffer[5] = 0x08;
|
||
temp *= -1;
|
||
}
|
||
else
|
||
{
|
||
SendBuffer[5] = 0x00;
|
||
}
|
||
byte tempInt = (byte) temp;
|
||
byte td = (tempInt / 10);
|
||
byte tf = tempInt - td * 10;
|
||
byte tempFloat = (temp - (float)tempInt) * 10;
|
||
|
||
SendBuffer[5] += (td << 4);
|
||
SendBuffer[4] = tf;
|
||
SendBuffer[4] |= (tempFloat << 4);
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::setHumidity(byte hum)
|
||
{
|
||
if (sens_type != THN132)
|
||
{
|
||
SendBuffer[6] = (hum / 16);
|
||
SendBuffer[6] += (hum - (SendBuffer[6] * 16)) << 4;
|
||
}
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void Oregon_TM::setComfort(float temp, byte hum)
|
||
{
|
||
if (sens_type != THN132)
|
||
{
|
||
if (hum > 70)
|
||
{
|
||
SendBuffer[7] = 0xC0;
|
||
return;
|
||
}
|
||
if (hum < 40)
|
||
{
|
||
SendBuffer[7] = 0x80;
|
||
return;
|
||
}
|
||
if (temp > 20 && temp < 25)
|
||
{
|
||
SendBuffer[7] = 0x40;
|
||
return;
|
||
}
|
||
else SendBuffer[7] = 0x00;
|
||
return;
|
||
}
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
bool Oregon_TM::transmit()
|
||
{
|
||
if (millis() >= time_marker_send && send_time)
|
||
{
|
||
SendPacket();
|
||
time_marker_send = millis() + send_time;
|
||
return true;
|
||
}
|
||
else return false;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
//Поддержка датчика THP
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
void Oregon_TM::setChannelTHP(byte channel)
|
||
{
|
||
SendBuffer[1] &= 0x0F;
|
||
SendBuffer[1] += channel << 4;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
void Oregon_TM::setBatteryTHP( word bat_voltage)
|
||
{
|
||
SendBuffer[6] = (bat_voltage & 0x0FF0) >> 4;
|
||
SendBuffer[7] &= 0x0F;
|
||
SendBuffer[7] += (bat_voltage & 0x000F) << 4;
|
||
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
void Oregon_TM::setTemperatureTHP(float bme_temperature)
|
||
{
|
||
word temp_code;
|
||
if (bme_temperature < -100 || bme_temperature > 100) temp_code = 0x0FFF;
|
||
else temp_code = (word)((bme_temperature + 100) * 10);
|
||
SendBuffer[2] = temp_code & 0x00FF;
|
||
SendBuffer[1] &= 0xF0;
|
||
SendBuffer[1] += (temp_code & 0x0F00) >> 8;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
void Oregon_TM::setHumidityTHP(float bme_humidity)
|
||
{
|
||
word hum_code;
|
||
if (bme_humidity > 100) hum_code = 0x0FFF;
|
||
else hum_code = (word)(bme_humidity * 10);
|
||
SendBuffer[3] = (hum_code & 0x0FF0) >> 4;
|
||
SendBuffer[4] &= 0x0F;
|
||
SendBuffer[4] += (hum_code & 0x000F) << 4;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
void Oregon_TM::setPressureTHP(float bme_pressure)
|
||
{
|
||
word pres_code;
|
||
if (bme_pressure < 500) pres_code = 0x0000;
|
||
else pres_code = (word)((bme_pressure - 500) * 10);
|
||
SendBuffer[5] = pres_code & 0x00FF;
|
||
SendBuffer[4] &= 0xF0;
|
||
SendBuffer[4] += (pres_code & 0x0F00) >> 8;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
void Oregon_TM::setErrorTHP()
|
||
{
|
||
SendBuffer[1] |= 0x0F;
|
||
SendBuffer[2] = 0xFF;
|
||
SendBuffer[3] = 0xFF;
|
||
SendBuffer[4] = 0xFF;
|
||
SendBuffer[5] = 0xFF;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
void Oregon_TM::calculateAndSetChecksumTHP()
|
||
{
|
||
byte CCIT_POLY = 0x07;
|
||
SendBuffer[7] = SendBuffer[7] & 0xF0;
|
||
SendBuffer[8] = 0x00;
|
||
SendBuffer[9] = 0x00;
|
||
byte summ = 0x00;
|
||
byte crc = 0x00;
|
||
byte cur_nible;
|
||
for (int i = 0; i < 8; i++)
|
||
{
|
||
cur_nible = (SendBuffer[i] & 0xF0) >> 4;
|
||
summ += cur_nible;
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
|
||
cur_nible = SendBuffer[i] & 0x0F;
|
||
summ += cur_nible;
|
||
crc ^= cur_nible;
|
||
for (int j = 0; j < 4; j++)
|
||
if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY;
|
||
else crc <<= 1;
|
||
}
|
||
SendBuffer[7] += summ & 0x0F;
|
||
SendBuffer[8] += summ & 0xF0;
|
||
SendBuffer[8] += crc & 0x0F;
|
||
SendBuffer[9] += crc & 0xF0;
|
||
}
|
||
|