From 7d343d3b57f10f12b8f32a120a38509cae984ad7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fabian=20Gro=C3=9Fe?= Date: Mon, 30 Dec 2019 12:11:26 +0100 Subject: [PATCH 1/3] Add PCR800 support Calculations taken from robwlakes/ArduinoWeatherOS --- Oregon_NR.cpp | 528 +++++++++++++++++++++++++++----------------------- Oregon_NR.h | 221 +++++++++++---------- 2 files changed, 401 insertions(+), 348 deletions(-) diff --git a/Oregon_NR.cpp b/Oregon_NR.cpp index 52ca4c5..1364c0f 100644 --- a/Oregon_NR.cpp +++ b/Oregon_NR.cpp @@ -14,8 +14,9 @@ // Receive only: // THN132N, -// WGR800, -// UVN800. +// WGR800, +// UVN800, +// PCR800. // // Aslo supported self-developed sensors. Please contact author for additional infromation. // @@ -39,44 +40,45 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Oregon Scientific v2.1 v3.0 +// ������ ���������� ������� ������������� ��� ������ � �������� ������ � ������� ������������� ��������� Oregon Scientific v2.1 � v3.0 // -// 14 2019 +// ��������� ���������� 14 ������� 2019 // -// +// �������������� ������ ��������� �������� // -// : +// ���� � ��������: // THGN132N (THGR122N, THGN123N), // RTGN318, // THGR810. -// : +// ������ ����: // THN132N, -// WGR800, -// UVN800. +// WGR800, +// UVN800, +// PCR800. // -// ( ) +// ����� �������������� ������� ����������� ���������� (�� �������������� ������������ ���������� � ������) // -// - OREGON_NR +// ���� ���� - ����� ���������� OREGON_NR ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Copyright (c) 2019 +// Copyright (c) 2019 ������ �������� // -// , -// ( ), , -// , , , , , , -// / , , , : +// ������ �������� ��������� �����, ���������� ����� ������� ������������ ����������� � ������������� ������������ +// (� ���������� ���������� ������������ �����������), ������������ ������������ ����������� ����������� ��� �����������, +// ������� �������������� ����� �� �������������, �����������, ���������, �������, ����������, ���������������, ����������������� +// �/��� ������� ����� ������������ �����������, � ����� �����, ������� ��������������� ������ ����������� �����������, ��� ���������� ��������� �������: // -// . +// ��������� ���� ����������� �� ��������� ����� � ������ ������� ������ ���� �������� �� ��� ����� ��� �������� ����� ������� ������������ �����������. // -// ܻ, - , , -// , , . -// - , , , , , -// - . +// ������ ����������� ����������� ��������������� ���� ���ܻ, ��� �����-���� ��������, ���� ���������� ��� ���������������, ������� �������� �������� +// �����������, ������������ �� ��� ����������� ���������� � ���������� ���������, �� �� ������������� ���. �� � ����� ������ ������ ��� ��������������� +// �� ����� ��������������� �� �����-���� �����, �� ����� ��� �� ���� �����������, � ��� �����, ��� �������� ���������, ������� ��� ���� ��������, +// ��������� ��-�� ������������� ������������ ����������� ��� ���� �������� � ����������� ������������. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//, ///////////////////////////////////// +//��, ��� ��������� � ����������///////////////////////////////////// #ifndef Oregon_NR_int #define Oregon_NR_int static volatile unsigned long pm; @@ -91,13 +93,13 @@ void receiver_interruption(void) { #endif if(digitalRead(RECEIVER_PIN)){ - // + //������ �������� pl = 0; pm = micros(); } else{ - // - // + //����� �������� + //����������� ����� ��������� � ����� pl = micros() - pm; //pm += pl; } @@ -110,7 +112,7 @@ Oregon_NR::Oregon_NR(byte MHZ, byte MHZ_INT) { INT_NO = MHZ_INT; RECEIVER_PIN = MHZ; - pinMode(MHZ, INPUT); // , + pinMode(MHZ, INPUT); // �����, �� ������� ��������� ������� } Oregon_NR::Oregon_NR(byte MHZ, byte MHZ_INT, byte led, bool pull_up) @@ -119,8 +121,8 @@ Oregon_NR::Oregon_NR(byte MHZ, byte MHZ_INT, byte led, bool pull_up) LED = led; PULL_UP = pull_up; RECEIVER_PIN = MHZ; - pinMode(MHZ, INPUT); // , - pinMode(LED, OUTPUT); // + pinMode(MHZ, INPUT); // �����, �� ������� ��������� ������� + pinMode(LED, OUTPUT); // ����� ���������� } ////////////////////////////////////////////////////////////////////// @@ -139,13 +141,13 @@ void Oregon_NR::stop() detachInterrupt(INT_NO); } ////////////////////////////////////////////////////////////////////// -// -//DEBUG_INFO - Serial +//������ � ������ ������ +//DEBUG_INFO - � Serial ��������� ���������� � ������� ������ ////////////////////////////////////////////////////////////////////// void Oregon_NR::capture(bool DEBUG_INFO) { //////////////////////////////////////////////////////// - // + // ������������ � ��������� ��������� //maybe_packet = 0; packets_received = 0; sens_type = 0; @@ -156,7 +158,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) //////////////////////////////////////////////////////// - // + //������ ������ � �������� noInterrupts(); pulse_length = pl; pl = 0; @@ -164,15 +166,15 @@ void Oregon_NR::capture(bool DEBUG_INFO) interrupts(); //////////////////////////////////////////////////////// - // + //������ ������� if (pulse_length != 0 && receive_status == FIND_PACKET){ - // , + //���� ������� ������ ������� ������ ��� ���������� ������ ���������, �� ��� ������ ������� if (pulse_marker - pre_marker > (PER_LENGTH2 * 2 + LENGTH_TOLERANCE) && ver == 2) start_pulse_cnt = 0; if (pulse_marker - pre_marker > (PER_LENGTH3 * 2 + LENGTH_TOLERANCE) && ver == 3) start_pulse_cnt = 0; if (start_pulse_cnt == 0){ //////////////////////////////////////////////////////// - // "" - + //������� ������ "����������" ������� - ���������� ��� ��������� if (pulse_length < (MAX_LENGTH2 + LENGTH_TOLERANCE) && pulse_length > (MIN_LENGTH2 - LENGTH_TOLERANCE) && catch2 ) { start_pulse_cnt++; pre_marker = pulse_marker; @@ -189,10 +191,10 @@ void Oregon_NR::capture(bool DEBUG_INFO) } else{ /////////////////////////////////////////////////////////// - // "" + //������� ��������� "����������" ������� if (pulse_length <= (MAX_LENGTH2 + LENGTH_TOLERANCE) && pulse_length >= (MIN_LENGTH2 - LENGTH_TOLERANCE) && catch2) { /////////////////////////////////////////////////////////// - // , + //���� ������� � ���������� �����, �� ��������� ������� �������� ��������� ��������� if(pulse_marker - pre_marker > (PER_LENGTH2*2-LENGTH_TOLERANCE) && pulse_marker - pre_marker < (PER_LENGTH2 * 2 + LENGTH_TOLERANCE) && ver == 2) { start_pulse_cnt++; @@ -200,8 +202,8 @@ void Oregon_NR::capture(bool DEBUG_INFO) pulse_length = 0; } /////////////////////////////////////////////////////////// - // - // + //��������� ������� ��������� � ������������ ����� + //��������� ��� ������ else { start_pulse_cnt = 1; @@ -213,7 +215,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) if (pulse_length <= (MAX_LENGTH3 + LENGTH_TOLERANCE) && pulse_length >= (MIN_LENGTH3 - LENGTH_TOLERANCE) && catch3) { /////////////////////////////////////////////////////////// - // , + //���� ������� � ���������� �����, �� ��������� ������� �������� ��������� ��������� if(pulse_marker - pre_marker > (PER_LENGTH3*2-LENGTH_TOLERANCE) && pulse_marker - pre_marker < (PER_LENGTH3 * 2 + LENGTH_TOLERANCE) && ver == 3) { start_pulse_cnt++; @@ -221,8 +223,8 @@ void Oregon_NR::capture(bool DEBUG_INFO) pulse_length = 0; } /////////////////////////////////////////////////////////// - // - // + //��������� ������� ��������� � ������������ ����� + //��������� ��� ������ else { start_pulse_cnt = 1; @@ -235,15 +237,15 @@ void Oregon_NR::capture(bool DEBUG_INFO) } //************************************************************************************* ///////////////////////////////////////////////////////////////////// - // - // , - // + // ���� ������ ������ ����� � ����� ����� �������� ������� + // �� ��� �������, � �������� � ����� ������� + // ����� �� ��� ������� ������ ���� �������� ����� ���������� ������� if (packet_number == 1 && (millis() - first_packet_end) > 200) receive_status = ANALIZE_PACKETS; if (packet_number == 1 && (!IS_ASSEMBLE || ver == 3 )) receive_status = ANALIZE_PACKETS; ////////////////////////////////////////////////////////////////////// - // , . + //���� ������� ������ ���������� ���������� ��������� � ������ ������, �� �������� ��� �����. �������� ���� ������ if (start_pulse_cnt == CATCH_PULSES && receive_status == FIND_PACKET) { @@ -263,10 +265,10 @@ void Oregon_NR::capture(bool DEBUG_INFO) } } ////////////////////////////////////////////////////////////////////// - // //////////////////////////////////////////////////////// + // ������ ������//////////////////////////////////////////////////////// if (receive_status == ANALIZE_PACKETS) { ////////////////////////////////////////////////////////////////////// - // , + //���� ������ ������ ����� �������, �� �� ����� � ������������ if ((ver ==2 && read_tacts < 136 && read_tacts2 < 136) || (ver ==3 && read_tacts < 80)) { receive_status = FIND_PACKET; @@ -274,16 +276,16 @@ void Oregon_NR::capture(bool DEBUG_INFO) packet_number = 0; return; } - // , + //��������� ����������, ����� ��������� ����� ��������� detachInterrupt(INT_NO); led_light(true); restore_sign = 0; - work_time = millis(); // - // - // - // v2 - 87 07 86 06, .. 883 395 - // v3 - 86 06 87 07 .. 838 350 + work_time = millis(); //������ ������� ��������� ������ + //���� ��������� ������ + //��� ������� ��� ����� �������� ��������� ����� ���� �������� + // v2 - 87 07 � ������� 86 06, �.�. ����� �������� 883�� � 395�� + // v3 - 86 06 � ������� 87 07 �.�. ����� �������� 838 � 350�� if (DEBUG_INFO && receiver_dump){ Serial.println(" "); Serial.print("SCOPE1 "); @@ -308,8 +310,8 @@ void Oregon_NR::capture(bool DEBUG_INFO) ////////////////////////////////////////////// - // - // . decode_tacts[] + //��������� ������ ������ + //�������������� ������. ������ ��������� � decode_tacts[] get_tacts(collect_data, read_tacts); bool halfshift; @@ -322,10 +324,10 @@ void Oregon_NR::capture(bool DEBUG_INFO) halfshift = 1; } ////////////////////////////////////////////// - // + //���� ������� ����������� synchro_pos = get_synchro_pos(collect_data); ////////////////////////////////////////////// - // + //������� ������� if (DEBUG_INFO){ if (packet_number == 2) Serial.print("1) "); if (packet_number == 1) Serial.print("RESULT "); @@ -351,7 +353,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) Serial.println (millis() / 1000); } ////////////////////////////////////////////// - // + //���������� ������������ ������ ������ if (packet_number == 2){ get_tacts(collect_data2, read_tacts2); @@ -395,12 +397,12 @@ void Oregon_NR::capture(bool DEBUG_INFO) ////////////////////////////////////////////// - // - // , + //������������� ������� + //���� ����� ����, �� � ������������ �� �� ���� if (packet_number == 1) result_data = collect_data; ////////////////////////////////////////////// - // , - // "" + //� ��� ���� ���, �� ����� ������ ������ + //��������� ����������� "��������" ������� ���� ������������ ����� if (packet_number == 2) { correlation = correlate_data(collect_data, collect_data2); if (DEBUG_INFO){ @@ -408,7 +410,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) Serial.println(correlation); } ////////////////////////////////////////////// - // , + //�������� ������ � �����, ��� ���������� ������ ������ ////////////////////////////////////////////// if (synchro_pos >= synchro_pos2) @@ -426,7 +428,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) } } ////////////////////////////////////////////// - // + //����� ������� ������� if (DEBUG_INFO && packet_number == 2){ Serial.print("RESULT "); byte* rdt = result_data; @@ -448,31 +450,31 @@ void Oregon_NR::capture(bool DEBUG_INFO) - //, - - . , + //���������, ���� �� ���-������ ���������� - ��������. ��� ��� ����� ���� ����, �� �������� ����� ������� ////////////////////////////////////////////// // if (get_data(halfshift, ver, result_data) > data_val && get_data(halfshift, ver, result_data) > data_val2 && ver == 2) // restore_sign ^= 8; ////////////////////////////////////////////// - // + //��������� �� �������� ������������������ ���� sens_type = 0; if (get_info_data(result_data, packet, valid_p)) { - sens_type = get_sensor(packet); // - restore_data(packet, sens_type); // - crc_c = check_CRC(packet, sens_type); // CRC, , - // , , + sens_type = get_sensor(packet); //���������� ��� ������ �� ���� ������� + restore_data(packet, sens_type); // ��������������� ������ �� ���� ������� + crc_c = check_CRC(packet, sens_type); // ��������� CRC, ���� ��� �����, �� ��� ������������ ���� ������ ���������� + //���� �� ��� ����� ���������� ��������, ������ �������, ��� ����� ���������� byte secresingV; if (sens_type == THGN132 || (sens_type & 0xFF00) == GAS) secresingV = PACKET_LENGTH - 4; if (sens_type == THN132) secresingV = PACKET_LENGTH - 6; for (byte www = 0; www < (PACKET_LENGTH - secresingV + 2); www++) if (valid_p[www] < 0x0f) crc_c = false; - // , ( ) - // - + //������ ������ ���������� ������ � ������, ���� ������� ��������� ������������������ (���� �������������) + //���� �� ���� ������������ - �� �� � ��� ������ ������������� if ( synchro_pos != 255 && packet_number == 1) captured = 1; if ( (synchro_pos2 != 255 || synchro_pos2 != 255) && packet_number == 2) captured = 1; - // + //������ ����� ������� �� ��������� if ((ver ==2 && read_tacts < 136) || (ver ==3 && read_tacts < 80)) captured = 0; } // else if (data_val >=64 || data_val2 >=64) maybe_packet = 1; @@ -503,7 +505,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) sens_wdir = 0; //////////////////////////////////////////////////////////////////////////////////////////////////// -// +//����������� �������� ������ //////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type == THGN132 || sens_type == THN132 || (sens_type & 0x0FFF)== RTGN318 || sens_type == THGR810) && crc_c){ @@ -531,12 +533,17 @@ void Oregon_NR::capture(bool DEBUG_INFO) lightness = get_light(packet); } - +if (sens_type == PCR800 && crc_c){ + sens_id = get_id(packet); + sens_battery = get_battery(packet); + sens_total_rain = get_total_rain(packet); // mm since last reset + sens_rain_rate = get_rain_rate(packet); // mm/hr +} #if ADD_SENS_SUPPORT == 1 ////////////////////////////////////////////////////////////////////////////////////////////////// -// +//����������� ����������� ������� �������� //////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type & 0xFF00) == GAS && crc_c){ sens_id = 0; @@ -551,7 +558,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) sens_CH = get_gas_CH(packet); } ////////////////////////////////////////////////////////////////////////////////////////////////// -// +//����������� �������� �������� ������������ //////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type & 0xFF00) == FIRE && crc_c){ sens_id = 0; @@ -563,7 +570,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) sens_lockalarm = get_fire_lockalarm(packet); } ////////////////////////////////////////////////////////////////////////////////////////////////// -// THP +//����������� �������� THP //////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type & 0xFF00) == THP && crc_c){ sens_chnl = get_gas_channel(packet); @@ -574,7 +581,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) } ////////////////////////////////////////////////////////////////////////////////////////////////// -// +//����������� �������� ���� � ���������� //////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type & 0xFF00) == CURRENT && crc_c){ sens_id = 0; @@ -587,7 +594,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) } ////////////////////////////////////////////////////////////////////////////////////////////////// -// +//����������� �������� ������� ���������� ���� //////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type & 0xFF00) == CAPRAIN && crc_c){ sens_id = 0; @@ -600,8 +607,8 @@ void Oregon_NR::capture(bool DEBUG_INFO) #endif //////////////////////////////////////////////////////////////////////////////// -// -// +//��������� ���������� +//���������� �� � �������� ��������� � �������� ������������� �������� work_time = millis() - work_time; packets_received = 0; if (data_val >= 64 && synchro_pos != 255) packets_received++; @@ -616,16 +623,16 @@ void Oregon_NR::capture(bool DEBUG_INFO) } } //////////////////////////////////////////////////////////////////////////////////////////////////// -// -//: cdptr - -// decode_tacts +//��������� �� ������ �������� ������������������ +//���������: cdptr - ��������� �� ���������� �������� ������������������ +//��������� ������� � ������ decode_tacts //////////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ -// - for(int bt = 0 ; bt < bitsize; bt++) decode_tacts[bt] = 2; // +//����� �������� + for(int bt = 0 ; bt < bitsize; bt++) decode_tacts[bt] = 2; //���������� ���� ���������� -// +//����������� ������ byte* cdp = cdptr; for(int bt = 0 ; bt < bitsize; bt++) { @@ -638,10 +645,10 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ } if (ver == 2 && decode_method == 2) { - if (*cdp == 0x88 || *cdp == 0x87 || *cdp == 0x86 || *cdp == 0x85 || *cdp == 0x84 || *cdp == 0x83 || *cdp == 0x78 || *cdp == 0x77 || *cdp == 0x68 || *cdp == 0x58 ) decode_tacts[bt] = 1; // 11 ( 87, 3 58 84) - if (*cdp == 0x00 || *cdp == 0x01 || *cdp == 0x02 || *cdp == 0x03 || *cdp == 0x10 || *cdp == 0x20 || *cdp == 0x30) decode_tacts[bt] = 0; // 00 ( 00, 3 30 03) - if (*cdp == 0x05 || *cdp == 0x06 || *cdp == 0x07 || *cdp == 0x08 || *cdp == 0x15 || *cdp == 0x16 || *cdp == 0x17 || *cdp == 0x24 || *cdp == 0x25 || *cdp == 0x34 || *cdp == 0x35) decode_tacts[bt] = 4; // 01 ( 07, 3 34) - if (*cdp == 0x50 || *cdp == 0x60 || *cdp == 0x70 || *cdp == 0x80 || *cdp == 0x51 || *cdp == 0x61 || *cdp == 0x71 || *cdp == 0x42 || *cdp == 0x52 || *cdp == 0x43 || *cdp == 0x53) decode_tacts[bt] = 3; // 10 ( 70, 3 43) + if (*cdp == 0x88 || *cdp == 0x87 || *cdp == 0x86 || *cdp == 0x85 || *cdp == 0x84 || *cdp == 0x83 || *cdp == 0x78 || *cdp == 0x77 || *cdp == 0x68 || *cdp == 0x58 ) decode_tacts[bt] = 1; // ���� 11 (� ������ 87, �� �� �� ������ �� 3 ����� ����� ���� �� 58 � 84) + if (*cdp == 0x00 || *cdp == 0x01 || *cdp == 0x02 || *cdp == 0x03 || *cdp == 0x10 || *cdp == 0x20 || *cdp == 0x30) decode_tacts[bt] = 0; // ���� 00 (� ������ 00, �� �� �� ������ �� 3 ����� ����� ���� �� 30 �� 03) + if (*cdp == 0x05 || *cdp == 0x06 || *cdp == 0x07 || *cdp == 0x08 || *cdp == 0x15 || *cdp == 0x16 || *cdp == 0x17 || *cdp == 0x24 || *cdp == 0x25 || *cdp == 0x34 || *cdp == 0x35) decode_tacts[bt] = 4; // ���� 01 (� ������ 07, �� �� �� ������ �� 3 ����� ����� ���� �� 34) + if (*cdp == 0x50 || *cdp == 0x60 || *cdp == 0x70 || *cdp == 0x80 || *cdp == 0x51 || *cdp == 0x61 || *cdp == 0x71 || *cdp == 0x42 || *cdp == 0x52 || *cdp == 0x43 || *cdp == 0x53) decode_tacts[bt] = 3; // ���� 10 (� ������ 70, �� �� �� ������ �� 3 ����� ����� ���� �� 43) } if (ver == 3 && decode_method == 1) { @@ -652,10 +659,10 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ } if (ver == 3 && decode_method == 2) { - if (*cdp == 0x87 || *cdp == 0x86 || *cdp == 0x85 || *cdp == 0x84 || *cdp == 0x83 || *cdp == 0x82 || *cdp == 0x78 || *cdp == 0x77 || *cdp == 0x76 || *cdp == 0x68 || *cdp == 0x67 ) decode_tacts[bt] = 1; // 11 ( 87, 3 58 84) - if (*cdp == 0x00 || *cdp == 0x01 || *cdp == 0x02 || *cdp == 0x03 || *cdp == 0x10 || *cdp == 0x20 || *cdp == 0x30) decode_tacts[bt] = 0; // 00 ( 00, 3 30 03) - if (*cdp == 0x05 || *cdp == 0x06 || *cdp == 0x07 || *cdp == 0x08 || *cdp == 0x15 || *cdp == 0x16 || *cdp == 0x17 || *cdp == 0x24 || *cdp == 0x25 || *cdp == 0x34 || *cdp == 0x35) decode_tacts[bt] = 4; // 01 ( 07, 3 34) - if (*cdp == 0x50 || *cdp == 0x60 || *cdp == 0x70 || *cdp == 0x80 || *cdp == 0x51 || *cdp == 0x61 || *cdp == 0x71 || *cdp == 0x42 || *cdp == 0x52 || *cdp == 0x43 || *cdp == 0x53) decode_tacts[bt] = 3; // 10 ( 70, 3 43) + if (*cdp == 0x87 || *cdp == 0x86 || *cdp == 0x85 || *cdp == 0x84 || *cdp == 0x83 || *cdp == 0x82 || *cdp == 0x78 || *cdp == 0x77 || *cdp == 0x76 || *cdp == 0x68 || *cdp == 0x67 ) decode_tacts[bt] = 1; // ���� 11 (� ������ 87, �� �� �� ������ �� 3 ����� ����� ���� �� 58 � 84) + if (*cdp == 0x00 || *cdp == 0x01 || *cdp == 0x02 || *cdp == 0x03 || *cdp == 0x10 || *cdp == 0x20 || *cdp == 0x30) decode_tacts[bt] = 0; // ���� 00 (� ������ 00, �� �� �� ������ �� 3 ����� ����� ���� �� 30 �� 03) + if (*cdp == 0x05 || *cdp == 0x06 || *cdp == 0x07 || *cdp == 0x08 || *cdp == 0x15 || *cdp == 0x16 || *cdp == 0x17 || *cdp == 0x24 || *cdp == 0x25 || *cdp == 0x34 || *cdp == 0x35) decode_tacts[bt] = 4; // ���� 01 (� ������ 07, �� �� �� ������ �� 3 ����� ����� ���� �� 34) + if (*cdp == 0x50 || *cdp == 0x60 || *cdp == 0x70 || *cdp == 0x80 || *cdp == 0x51 || *cdp == 0x61 || *cdp == 0x71 || *cdp == 0x42 || *cdp == 0x52 || *cdp == 0x43 || *cdp == 0x53) decode_tacts[bt] = 3; // ���� 10 (� ������ 70, �� �� �� ������ �� 3 ����� ����� ���� �� 43) } if (decode_method == 3) { @@ -673,7 +680,7 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ *cdp++; } -// +// ������ ����������� if (receiver_dump) { byte* cdp = cdptr; @@ -696,45 +703,45 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ } -// , -// +// ������������ ��, ��� ������ � ���� +//��������� ��������� �� �������� ������������������ for(int bt = 1; bt < bitsize; bt++) { // if (decode_tacts[bt] == 2) { - //0 0X - + //�0 0X - ����������� if ((decode_tacts[bt - 1] == 0 || decode_tacts[bt - 1] == 3) && (decode_tacts[bt] == 0 || decode_tacts[bt] == 4)) decode_tacts[bt] = 2; - //1 1X - + //�1 1X - ����������� if ((decode_tacts[bt - 1] == 1 || decode_tacts[bt - 1] == 4) && (decode_tacts[bt] == 1 || decode_tacts[bt] == 3)) decode_tacts[bt] = 2; } } -// +//�������������� ��������� ������ for(int bt = 1; bt < (bitsize - 1); bt++) { if (decode_tacts[bt] == 2) { - //0 __ 0 - //0 11 0 + //�0 __ 0� + //�0 11 0� if ((decode_tacts[bt - 1] == 0 || decode_tacts[bt - 1] == 3) && (decode_tacts[bt + 1] == 0 || decode_tacts[bt + 1] == 4)) { decode_tacts[bt] = 1; restore_sign ^= 2; } - //0 __ 1 - //0 10 1 + //�0 __ 1� + //�0 10 1� if ((decode_tacts[bt - 1] == 0 || decode_tacts[bt - 1] == 3) && (decode_tacts[bt + 1] == 1 || decode_tacts[bt + 1] == 3)){ decode_tacts[bt] = 3; restore_sign ^= 2; } - //1 __ 0 - //1 01 0 + //�1 __ 0� + //�1 01 0� if ((decode_tacts[bt - 1] == 1 || decode_tacts[bt - 1] == 4) && (decode_tacts[bt + 1] == 0 || decode_tacts[bt + 1] == 4)){ decode_tacts[bt] = 4; restore_sign ^= 2; } - //1 __ 1 - //1 00 1 + //�1 __ 1� + //�1 00 1� if ((decode_tacts[bt - 1] == 1 || decode_tacts[bt - 1] == 4) && (decode_tacts[bt + 1] == 1 || decode_tacts[bt + 1] == 3)){ decode_tacts[bt] = 0; restore_sign ^= 2; @@ -742,20 +749,20 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ } } - // + //�������������� ���������� ���������� cdp = cdptr; for(int bt = 1 ; bt < (bitsize - 1); bt++) { if (decode_tacts[bt] == 2) { - //0 _0 - //0 10 + //�0 _0 + //�0 10 if ((*cdp & 0x0f) < 0x05 && (decode_tacts[bt - 1] == 0 || decode_tacts[bt - 1] == 3)){ decode_tacts[bt] = 3; restore_sign ^= 1; } - //1 _1 - //1 01 + //�1 _1 + //�1 01 if ((*cdp & 0x0f) > 0x04 && (decode_tacts[bt - 1] == 1 || decode_tacts[bt - 1] == 4)){ decode_tacts[bt] = 4; restore_sign ^= 1; @@ -776,22 +783,22 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ *cdp++; } - // , - :) + //����� ��������� ��������� �� �������� ������������������, � �� ��� �� ��� ����������� - ���������� :) for(int bt = 1; bt < bitsize; bt++) { { - //0 0X - + //�0 0X - ����������� if ((decode_tacts[bt - 1] == 0 || decode_tacts[bt - 1] == 3) && (decode_tacts[bt] == 0 || decode_tacts[bt] == 4)) decode_tacts[bt] = 2; - //1 1X - + //�1 1X - ����������� if ((decode_tacts[bt - 1] == 1 || decode_tacts[bt - 1] == 4) && (decode_tacts[bt] == 1 || decode_tacts[bt] == 3)) decode_tacts[bt] = 2; } *cdp++; } -// -// , +//����������� ������ ������ �� ��������� +//���� ��������� ���������� �� ��������� ������ ��������, �� ����� ������ � ������ ������ //001100110011 -> v2 if (/*decode_tacts[0] == 0 && decode_tacts[1] == 1 &&*/ decode_tacts[2] == 0 && decode_tacts[3] == 1 && decode_tacts[4] == 0 && decode_tacts[5] == 1 && ver == 3){ @@ -814,7 +821,7 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ restore_sign ^=4; } -// +// ������ ����������� if (receiver_dump) { byte* cdp = cdptr; @@ -836,16 +843,16 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ return; } //////////////////////////////////////////////////////////////////////////////////////////////////// -// -//: cdptr - -// btt - . , -// "" - . -// btt=0 btt=1 +//��������� �� �������� ������������������ ������� +//���������: cdptr - ��������� �� ���������� ������ +// btt - �������� � ������. �������� �� ���� ��� ������� ����� ������� ������������ �����, � �������� ��������� ������ +// ������� ���������� �������� ��� "��������" ����������� - ���������� �������� ������� ������. +// ��������� �������� � btt=0 � btt=1 �������� ������ //////////////////////////////////////////////////////////////////////////////////////////////////// -int Oregon_NR::get_data(int btt, byte p_ver, byte* cdptr){ //btt - , +int Oregon_NR::get_data(int btt, byte p_ver, byte* cdptr){ //btt - �������� �� ���� ��� ������� ����� ������� ������������ �����, � �������� ��������� ������ byte* cdp = cdptr; -// +//������ ������ for(int bt=0 ; bt(129)) packet_validity += *cdp - 128; if (*cdp<(127)) packet_validity += 128 - *cdp; cdp++; } - return packet_validity; // - + return packet_validity; //���������� ���-�� ����������� ������ } if (p_ver == 3){ for(int bt = 1 ; bt < READ_BITS; bt++){ - if (*(cdp - 1) > 128) // 1 + if (*(cdp - 1) > 128) // ���� �� ����� ���� 1 { - if (decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 1) *cdp -= 2; // 00 11 - 0 - if (decode_tacts[bt - btt] == 3 || decode_tacts[bt - btt] == 4) *cdp += 2; // 01 10 - 1 + if (decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 1) *cdp -= 2; // ���� 00 ��� 11 - �� ����� 0 + if (decode_tacts[bt - btt] == 3 || decode_tacts[bt - btt] == 4) *cdp += 2; // ���� 01 ��� 10 - �� ����� 1 } - if (*(cdp - 1) < 128) // 0 + if (*(cdp - 1) < 128) // ���� �� ����� ���� 0 { - if (decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 1) *cdp += 2; // 00 11 - 1 - if (decode_tacts[bt - btt] == 3 || decode_tacts[bt - btt] == 4) *cdp -= 2; // 01 10 - 0 + if (decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 1) *cdp += 2; // ���� 00 ��� 11 - �� ����� 1 + if (decode_tacts[bt - btt] == 3 || decode_tacts[bt - btt] == 4) *cdp -= 2; // ���� 01 ��� 10 - �� ����� 0 } - // , . + // ���� �� ����� ��������� ���, �� ������ ����� �� ������� ������������ ����� ��� �����. ������� �� ��������� ��� ����� - // + //�������������� ���������� ��� �������� ��� ����� � ���� if (*(cdp - 1) == 128 && *(cdp - 2) == 128) { - //0 __ __ 0 - + //0 __ __ 0 - �� �������� if ((decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 3) && (decode_tacts[bt - btt - 2] == 0 || decode_tacts[bt - btt - 2] == 4)) { if (*(cdp - 2) > 128) *cdp += 1; @@ -908,16 +915,16 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ } else { - //1 __ __ 0 0 __ __ 1- + //1 __ __ 0 ��� 0 __ __ 1- �������� if (*(cdp - 2) > 128) *cdp -= 1; if (*(cdp - 2) < 128) *cdp += 1; } } - // + //�������������� ���������� ��� �������� ��� ����� � ���� if (*(cdp - 1) == 128 && *(cdp - 2) == 128 && *(cdp - 3) == 128) { - //0 __ __ 0 - + //0 __ __ 0 - �� �������� if ((decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 3) && (decode_tacts[bt - btt - 3] == 0 || decode_tacts[bt - btt - 3] == 4)) { if (*(cdp - 2) > 128) *cdp += 1; @@ -925,16 +932,16 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ } else { - //1 __ __ 0 0 __ __ 1- + //1 __ __ 0 ��� 0 __ __ 1- �������� if (*(cdp - 2) > 128) *cdp -= 1; if (*(cdp - 2) < 128) *cdp += 1; } } - // + //�������������� ���������� ��� �������� ������ ����� � ���� if (*(cdp - 1) == 128 && *(cdp - 2) == 128 && *(cdp - 3) == 128 && *(cdp - 4) == 128) { - //0 __ __ 0 - + //0 __ __ 0 - �� �������� if ((decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 3) && (decode_tacts[bt - btt - 4] == 0 || decode_tacts[bt - btt - 4] == 4)) { if (*(cdp - 2) > 128) *cdp += 1; @@ -942,31 +949,31 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ } else { - //1 __ __ 0 0 __ __ 1- + //1 __ __ 0 ��� 0 __ __ 1- �������� if (*(cdp - 2) > 128) *cdp -= 1; if (*(cdp - 2) < 128) *cdp += 1; } } - // . + //������ ����� � ������� ����������� ����� �� ����� �� ������������. - // - + //������������ ���-�� ����������� ��� � ������ if (*cdp>(129)) packet_validity += *cdp - 128; if (*cdp<(127)) packet_validity += 128 - *cdp; cdp++; } - return packet_validity; // - + return packet_validity; //���������� ���-�� ����������� ������ } } //////////////////////////////////////////////////////////////////////////////////////////////////// -// 16384 -//.. 61 -// . . 8 . -// 1 . - 0x00. 088. -//cdptr - , -//dtl - +//������������� ������ � �������� ������������� 16384�� +//�.�. ������ ��� � 61��� +//������� ���� ������������� ����. ���� ������� �� ��� ���������. � ������ ��������� ���������� 8 ���������. +//��� ������� ������� ��� ��������� ����������� 1 � ���������������� �����. ���������� ������� - 0x00. ������� ������� � ����� 0�88. +//cdptr - ��������� �� ������� ������, ���� ������������ ������ +//dtl - ��������� �� ���������� ��������� ������ //////////////////////////////////////////////////////////////////////////////////////////////////// int Oregon_NR::collect(byte* cdptr){ @@ -975,43 +982,43 @@ int Oregon_NR::collect(byte* cdptr){ byte nulls_found = 0; byte bt2 = 0; ////////////////////////////////////////////////////// - // ( + 1/16 ) + //������ �������� � ����� ������� (����� ���������� �������� ������� + 1/16 �����) if (ver == 2) { - pre_marker += 946; // - *cdp = 0x87; // - 11. ! + pre_marker += 946; //��� ����� + *cdp = 0x87; //������ ��� ����� �������� - 11. �� �� ������� �������! cdp++; } if (ver == 3) { - pre_marker += 1434; // - *cdp = 0x07; // - 0101. ! + pre_marker += 1434; //��� ����� + *cdp = 0x07; //������ ������ ����� �������� - 0101. �� �� ������� �������! *(cdp + 1) = 0x07; cdp += 2; } ////////////////////////////////////////////////////// - // - // v3 - 104, THN132 - 76 + 3 111, + //�������� ������ ������ � ������ + // ������������ ����� �������� ��� v3 - 104����, THN132 - 76 ��� + ��� ������� 3 ���� 111, ������� �� ��� ����� byte bt; for (bt = 0 ; bt < READ_BITS2; bt++) { *cdp = 0; - for (byte ckl = 0; ckl < 8; ckl++) { // 8 + for (byte ckl = 0; ckl < 8; ckl++) { // ������ 8 ��� �� �������� pre_marker += 61; while (micros() < pre_marker); - if (digitalRead(RECEIVER_PIN)) *cdp += 0x10; // + if (digitalRead(RECEIVER_PIN)) *cdp += 0x10; // ��������� ��������� � ������� �������� } for (byte ckl = 0; ckl < 8; ckl++) { pre_marker += 61; while (micros() < pre_marker); - if (digitalRead(RECEIVER_PIN)) *cdp += 1; // . . + if (digitalRead(RECEIVER_PIN)) *cdp += 1; // � ��������� �������� ��������� ��������� � ������� ��������. ��� �������� ������. } bt2++; - // 976.5625 - // 7 4 976 976.5714 + 0.009% + // ��������� ������ 976.5625 + // ������ 7 ������ ��������� 4��� ��� ������������ ������� � 976��� �� 976.5714��� + 0.009% if (bt2 == 7) { pre_marker += (4 + timing_correction) ; @@ -1019,20 +1026,20 @@ int Oregon_NR::collect(byte* cdptr){ } ///////////////////////////////////////////// - // - // , - // , , + //���� ����� �� ������� ���������� ��������� + //����� ���������, � �� ����������� �� ������� + //���� � ������ ��������� ����� ������� ��� ������ ������, �� ��� ��������� �����������, ��� ��������� ��������� ������ yield(); if ((*cdp & 0xf0) < 0x30 && (*cdp & 0x0f) < 0x05) nulls_found++; else nulls_found = 0; cdp++; ///////////////////////////////////////////// - // empty_space , - // . - //empty_space - , - // , - // , + //���� ����� empty_space ������ ����� � ������, �� + //��� ��������� ����� ����� �������. ������ ������ ��� ������ + //empty_space - ����� ������������, ������� �� ���� �������� � ������ ������� + //���� ���������, �������� ������� � ������������ ������ + //���� ���������, �� ����� �� ���������� ������ � ������ ���������� ������ if (nulls_found > empty_space ) return bt; @@ -1045,17 +1052,17 @@ int Oregon_NR::collect(byte* cdptr){ ///////////////////////////////////////////// - // + //��� ������� ������� ���������� ��������� while (micros() < pre_marker); } return bt; } //////////////////////////////////////////////////////////////////////////////////////////////////// -// -// -// -// >0 - , <0 - +//����������� �������� ������� ���� ������������ ����� +//� �������� ���������� ���������� ��������� �� ������� ������ +// �������������� �������� +// >0 - ������ ����� ������� ������, <0 - ������ ����� ������� ������ //////////////////////////////////////////////////////////////////////////////////////////////////// int Oregon_NR::correlate_data(byte* ser1, byte* ser2){ @@ -1067,7 +1074,7 @@ int Oregon_NR::correlate_data(byte* ser1, byte* ser2){ byte* s1; byte* s2; byte* s2t = ser2; - // + //������� ������ ����� ������������ ������� for (byte sht = 0; sht < READ_BITS; sht++){ s1 = ser1; s2 = s2t; @@ -1088,7 +1095,7 @@ int Oregon_NR::correlate_data(byte* ser1, byte* ser2){ } } -// - +//������ �������� -����� ����� ������������ ������� byte* s1t = ser1; for (byte sht = 0; sht < READ_BITS; sht++){ @@ -1104,7 +1111,7 @@ int Oregon_NR::correlate_data(byte* ser1, byte* ser2){ yield(); s1t++; } -// +// ���� ��������� ���������� ��� ����� ��������� for (int i = 0; i < READ_BITS; i++){ @@ -1113,15 +1120,15 @@ int Oregon_NR::correlate_data(byte* ser1, byte* ser2){ best_shift_back = i; } } - // + //� ���������� ����� ������ �� ���� if (best_correl_back > best_correl) return -best_shift_back; else return best_shift; } //////////////////////////////////////////////////////////////////////////////////////////////////// -// -// -// , .. . -//shift - +//������ �� ���� ������� +//� �������� ���������� ���������� ��������� �� ������� ������ +// ������ ������ ������ ���� �������������� �����, �.�. ��� ������� ����� ����� ������� ���������. +//shift - �������� ������ ������ �������������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_NR::assemble_data(byte* s1, byte* s2, int shift){ @@ -1147,10 +1154,10 @@ void Oregon_NR::assemble_data(byte* s1, byte* s2, int shift){ } } //////////////////////////////////////////////////////////////////////////////////////////////////// -// . 0xFF - +//���������� ������� ����������� � �������. 0xFF - ��� ����������� // -//code - -//result - +//code - ��������� �� �������������� ������� ������������������ +//result - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// int Oregon_NR::get_synchro_pos(byte* code){ @@ -1171,27 +1178,27 @@ int Oregon_NR::get_synchro_pos(byte* code){ cp++; } if (!syn_found) return 0xFF; - // , , , . . - // ! - - // 16-3 = 13 . 10!!! + //������������������ �����, �� ���� ���������, ��� ����� ���� ��� ���������, �. �. ��������� ������� + // � ��������� �� ����� ���� �����! - ��� ������� + //��������� ���� ������������� �� 16-3 = 13 ����� �����. �� ���� �� �� 10!!! for (byte g = i; i - g < 10 && g > 0; g --){ cp --; - if (*cp < 127) return 0xFF; // . ! + if (*cp < 127) return 0xFF; // ����� ������������ � ��������� �� ����� ���� ���������� ����. ��� ��� �����������! } return (byte) i; } //////////////////////////////////////////////////////////////////////////////////////////////////// -// -//code - -//result - -//valid - +//������ ������� ������� +//code - ��������� �� �������������� ������� ������������������ +//result - ��������� �� ������� ������� +//valid - ��������� �� ����� ������������� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// int Oregon_NR::get_info_data(byte* code, byte* result, byte* valid){ byte* rd = result; byte* vd = valid; - // + //������ ������� for (int l = 0; l < PACKET_LENGTH; l++){ *vd = 0; *rd = 0; @@ -1203,20 +1210,20 @@ int Oregon_NR::get_info_data(byte* code, byte* result, byte* valid){ int csm; for (csm = 0; csm < 30; csm++){ - if ( !consist_synchro && (*code < 128 && *(code + 1) > 128 && *(code + 2) < 128 && *(code + 3) > 128)) break; // 0101 + if ( !consist_synchro && (*code < 128 && *(code + 1) > 128 && *(code + 2) < 128 && *(code + 3) > 128)) break; //������� ������������������ 0101 if ( consist_synchro && (*code < 127 && *(code + 1) > 129 && *(code + 2) < 127 && *(code + 3) > 129)) break; code++; } - // 20 , ! + // ���������� � ������ 20 ����� �� ������, ����� ����� �� ����������� �� ������ ������ ���������! if (ver == 2 & csm > 22) return 0; - // + // ��� ������� ������ ��������� ����� ���� if (ver == 3 & csm > 30) return 0; - // + //��������� �� ������ ���������� code += 4; int ii = 0; for (int i = 0; i < READ_BITS - csm; i++) { - // + // ����� �� ����� �� ������� if (i >= PACKET_LENGTH * 4) break; byte multipl; switch (ii){ @@ -1243,18 +1250,18 @@ int Oregon_NR::get_info_data(byte* code, byte* result, byte* valid){ } // //////////////////////////////////////////////////////////////////////////////////////////////////// -// +//������� ����������� ������ � �������� //////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////// -// -//oregon_data - +//���������� �������� ����������� +//oregon_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// float Oregon_NR::get_temperature(byte* oregon_data){ if (((sens_type & 0x0FFF) == RTGN318 || sens_type == THGR810 || sens_type == THGN132 || sens_type == THN132) && crc_c) { float tmprt; oregon_data += 8; - // : + //���������� ��������� ������: for (int g=0;g < 4; g++) if (*(oregon_data + g) > 9) *(oregon_data + g) = *(oregon_data + g) - 8; tmprt += *(oregon_data) * 0.1; tmprt += *(oregon_data + 1); @@ -1264,16 +1271,16 @@ float Oregon_NR::get_temperature(byte* oregon_data){ // else return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////// -// . -//oregon_data - +//���������� ��� �������. +//oregon_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// word Oregon_NR::get_sensor(byte* oregon_data){ return (word)(*(oregon_data))*0x1000 + (*(oregon_data+1))*0x0100 + (*(oregon_data+2))*0x10 + *(oregon_data+3); } //////////////////////////////////////////////////////////////////////////////////////////////////// -// -//oregon_data - +//���������� �������� ������ +//oregon_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_channel(byte* oregon_data){ if (crc_c) @@ -1309,15 +1316,15 @@ byte Oregon_NR::get_battery(byte* oregon_data){ else return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////// -// -//oregon_data - +//���������� �������� ��������� +//oregon_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// float Oregon_NR::get_humidity(byte* oregon_data){ if (((sens_type & 0x0FFF) == RTGN318 || sens_type == THGR810 || sens_type == THGN132) && crc_c ){ byte tmprt = 0; oregon_data += 12; - // : + //���������� ��������� ������: for (int g=0; g < 2; g++) if (*(oregon_data + g) > 9) *(oregon_data + g) = *(oregon_data + g) - 8; tmprt = *(oregon_data); tmprt += *(oregon_data + 1) * 10; @@ -1326,8 +1333,8 @@ float Oregon_NR::get_humidity(byte* oregon_data){ else return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////// -// id -//oregon_data - +//���������� id ������� +//oregon_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_id(byte* oregon_data){ if (((sens_type & 0x0FFF) == RTGN318 || sens_type == THGR810 || sens_type == THGN132 || sens_type == THN132 || sens_type == WGR800 || sens_type == UVN800) && crc_c) @@ -1342,8 +1349,8 @@ byte Oregon_NR::get_id(byte* oregon_data){ } //////////////////////////////////////////////////////////////////////////////////////////////////// -// /c -//oregon_data - +//���������� ������� �������� ����� � �/c +//oregon_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// float Oregon_NR::get_avg_windspeed(byte* oregon_data) { @@ -1357,8 +1364,8 @@ float Oregon_NR::get_avg_windspeed(byte* oregon_data) } //////////////////////////////////////////////////////////////////////////////////////////////////// -// /c -//oregon_data - +//���������� ������� ������������� ������ ����� � �/c +//oregon_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// float Oregon_NR::get_max_windspeed(byte* oregon_data) { @@ -1372,22 +1379,22 @@ float Oregon_NR::get_max_windspeed(byte* oregon_data) } //////////////////////////////////////////////////////////////////////////////////////////////////// -// -//oregon_data - +//���������� ����������� ����� � ���������� +//oregon_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_winddirection(byte* oregon_data) { if (sens_type == WGR800 && crc_c){ byte tmprt; return *(oregon_data + 8) & 0x0F; - // 0-N, 1-NNE, 2-NE, 3-ENE, 4-E, 5-ESE, 6-SE, 7-SSE, 8-S, 9-SSW, A-SW, B-WSW, C-W, D-WNW, E-NW,F-NNW + //��������� 0-N, 1-NNE, 2-NE, 3-ENE, 4-E, 5-ESE, 6-SE, 7-SSE, 8-S, 9-SSW, A-SW, B-WSW, C-W, D-WNW, E-NW,F-NNW } else return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////// -// UV- -//oregon_data - +//���������� UV-������ +//oregon_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_UV(byte* oregon_data) { @@ -1401,8 +1408,8 @@ byte Oregon_NR::get_UV(byte* oregon_data) } //////////////////////////////////////////////////////////////////////////////////////////////////// -// -//oregon_data - +//���������� ������������ � �������� �������� +//oregon_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_light(byte* oregon_data) { @@ -1416,10 +1423,39 @@ byte Oregon_NR::get_light(byte* oregon_data) else return 0; } +float Oregon_NR::get_total_rain(byte* oregon_data) +{ + if (sens_type == PCR800 && crc_c){ + float tmprt; + tmprt = *(oregon_data + 17) * 100000; + tmprt += *(oregon_data + 16) * 10000; + tmprt += *(oregon_data + 15) * 1000; + tmprt += *(oregon_data + 14) * 100; + tmprt += *(oregon_data + 13) * 10; + tmprt += *(oregon_data + 12); + tmprt *= 25; + return tmprt / 1000; + } + else return 0; +} +float Oregon_NR::get_rain_rate(byte* oregon_data) +{ + if (sens_type == PCR800 && crc_c){ + float tmprt; + tmprt = *(oregon_data + 7) * 10000; + tmprt += *(oregon_data + 8) * 1000; + tmprt += *(oregon_data + 9) * 100; + tmprt += *(oregon_data + 10) * 10; + tmprt += *(oregon_data + 11); + tmprt *= 25; + return tmprt / 1000; + } + else return 0; +} //////////////////////////////////////////////////////////////////////////////////////////////////// -// CRC -//oregon_data - +//�������� CRC +//oregon_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// bool Oregon_NR::check_CRC(byte* oregon_data, word sens_type){ @@ -1538,6 +1574,16 @@ bool Oregon_NR::check_CRC(byte* oregon_data, word sens_type){ return (resived_crc == crc)? 1 : 0; } + if (sens_type == PCR800){ + //CHKSUM 1...17 + for(int x=0; x < 18; x++){ + crc += *pp; + pp++; + } + + resived_crc = (*(oregon_data+18))+(*(oregon_data+19))*0x10; + return (resived_crc == crc)? 1 : 0; + } if (sens_type==THN132){ //CHKSUM 1...12 @@ -1590,7 +1636,7 @@ bool Oregon_NR::check_CRC(byte* oregon_data, word sens_type){ return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////// -// +//������������� ������ �� ���� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_NR::restore_data(byte* oregon_data, word sens_type){ @@ -1628,8 +1674,8 @@ void Oregon_NR::led_light(bool led_on) { // #if ADD_SENS_SUPPORT == 1 //////////////////////////////////////////////////////////////////////////////////////////////////// -// GAS -//gas_data - +//������� ����������� ������ �������� GAS +//gas_data - ��������� �� ������� ������� //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_gas_channel(byte* gas_data){ diff --git a/Oregon_NR.h b/Oregon_NR.h index b866329..6725bf0 100644 --- a/Oregon_NR.h +++ b/Oregon_NR.h @@ -16,8 +16,9 @@ // Receive only: // THN132N, -// WGR800, -// UVN800. +// WGR800, +// UVN800, +// PCR800. // // Aslo supported self-developed sensors. Please contact author for additional infromation. // @@ -41,88 +42,90 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Oregon Scientific v2.1 v3.0 +// ������ ���������� ������� ������������� ��� ������ � �������� ������ � ������� ������������� ��������� Oregon Scientific v2.1 � v3.0 // -// 14 2019 +// ��������� ���������� 14 ������� 2019 // -// +// �������������� ������ ��������� �������� // -// : +// ���� � ��������: // THGN132N (THGR122N, THGN123N), // RTGN318, // THGR810. -// : +// ������ ����: // THN132N, -// WGR800, -// UVN800. +// WGR800, +// UVN800, +// PCR800. // -// ( ) +// ����� �������������� ������� ����������� ���������� (�� �������������� ������������ ���������� � ������) // -// - OREGON_NR +// ���� ���� - ����� ���������� OREGON_NR ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Copyright (c) 2019 +// Copyright (c) 2019 ������ �������� // -// , -// ( ), , -// , , , , , , -// / , , , : +// ������ �������� ��������� �����, ���������� ����� ������� ������������ ����������� � ������������� ������������ +// (� ���������� ���������� ������������ �����������), ������������ ������������ ����������� ����������� ��� �����������, +// ������� �������������� ����� �� �������������, �����������, ���������, �������, ����������, ���������������, ����������������� +// �/��� ������� ����� ������������ �����������, � ����� �����, ������� ��������������� ������ ����������� �����������, ��� ���������� ��������� �������: // -// . +// ��������� ���� ����������� �� ��������� ����� � ������ ������� ������ ���� �������� �� ��� ����� ��� �������� ����� ������� ������������ �����������. // -// ܻ, - , , -// , , . -// - , , , , , -// - . +// ������ ����������� ����������� ��������������� ���� ���ܻ, ��� �����-���� ��������, ���� ���������� ��� ���������������, ������� �������� �������� +// �����������, ������������ �� ��� ����������� ���������� � ���������� ���������, �� �� ������������� ���. �� � ����� ������ ������ ��� ��������������� +// �� ����� ��������������� �� �����-���� �����, �� ����� ��� �� ���� �����������, � ��� �����, ��� �������� ���������, ������� ��� ���� ��������, +// ��������� ��-�� ������������� ������������ ����������� ��� ���� �������� � ����������� ������������. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Oregon Scientific: +// ������������� ������� �� ��������� �������� Oregon Scientific: // -#define THGN132 0x1D20 // , , 3 , -#define THN132 0xEC40 // , 3 , -#define RTGN318 0xDCC3 // , , 5 , -#define THGR810 0xF824 // , , 10 , -#define WGR800 0x1984 // -#define UVN800 0xD874 // -, ( XOR ) +#define THGN132 0x1D20 // �����������, ���������, 3 ������, +#define THN132 0xEC40 // �����������, 3 ������, +#define RTGN318 0xDCC3 // �����������, ���������, 5 �������, +#define THGR810 0xF824 // �����������, ���������, 10 �������, +#define WGR800 0x1984 // ����������� � �������� ����� +#define UVN800 0xD874 // ��-������, ������������ (������� XOR �� ��������������� ������) +#define PCR800 0x2914 // Rain gauge // -// : -#define THP 0x5500 // , , , 8 , 3- , -#define GAS 0xAA00 // , , CH4, 8 , -#define FIRE 0xBB00 // 22 72 -#define CURRENT 0xEE00 // , , 8 , -#define CAPRAIN 0x8800 // +// ������� ����������� ����������: +#define THP 0x5500 // �����������, ���������, ��� ��������, 8 �������, ������ �� 3-�� ������� ��, +#define GAS 0xAA00 // �����������, ���������, ������������ �� � CH4, 8 �������, +#define FIRE 0xBB00 // �������� �������� �������� ����� �������� ��22 � ��72 +#define CURRENT 0xEE00 // ���, ����������, 8 �������, +#define CAPRAIN 0x8800 // ��������� ����������� ������ ������� // -// -#define ADD_SENS_SUPPORT 1 // - -#define IS_ASSEMBLE 1 // ( v2) - ! +//����� ����������� ����� �������� ��� �������� �������� +#define ADD_SENS_SUPPORT 1 // �������� �������������� ����� �������� ����������� ���������� - ���������� ������������� �������� ��� +#define IS_ASSEMBLE 1 // �������� �� ������� �� ���� ����������� ������� ���� ����� (��� v2) - ���������� ������ �������� ���! // -// +// ����� ����������� ����� �������� ��� ��������� ���������� ����� -#define MAX_LENGTH2 976 // v2 - , -#define MIN_LENGTH2 883 // ( v2 93), .. 883, +#define MAX_LENGTH2 976 // ������������ ����� �������� ��������� v2 - �� ������ �������, ����� ������� ������ �� ������ ���������� +#define MIN_LENGTH2 883 // ����������� ����� �������� ��� ������� (��� v2 �������� ��������� �� 93���), �.�. ������ ���� �� ������ 883���, -#define MAX_LENGTH3 488 // v3 - , -#define MIN_LENGTH3 330 // ( v2 138), .. 350, +#define MAX_LENGTH3 488 // ������������ ����� �������� ��������� v3 - �� ������ �����������, ����� ������� ������ �� ������ ���������� +#define MIN_LENGTH3 330 // ����������� ����� �������� ��� ������� (��� v2 �������� ��������� �� 138���), �.�. ������ ���� �� ������ 350���, -#define LENGTH_TOLERANCE 64 // . - // " " +#define LENGTH_TOLERANCE 64 // ���������� ���������� ��� ����� ��������. ������� �� �������� + // � ����������� �� ������ ������� ����� "������� ����� ���������" -#define CATCH_PULSES 3 // . 2 - 4. - // - - // - , +#define CATCH_PULSES 3 // ������� ������ ���������� ��������� ��� ������ �������. ������������� 2 - 4. + // ������ - ����� �� ������� ����� � �������� ������� ����� + // ������ - ����� ���������� �����, ������ ���������� �� ������ ����� -// ! +//��� ��������� ������� �� ����! #define FIND_PACKET 1 #define ANALIZE_PACKETS 2 -#define PER_LENGTH2 976 // . v2 v3 976,56 (1024) +#define PER_LENGTH2 976 // ������ �������� ������. ��� v2 � v3 976,56��� (1024��) #define PER_LENGTH3 488 -#define READ_BITS 105 // -#define READ_BITS2 210 // * 2 -#define PACKET_LENGTH 20 // ( ) +#define READ_BITS 105 // ������������ ����� ������ � ������ +#define READ_BITS2 210 // ������������ ����� ������ � ������ * 2 +#define PACKET_LENGTH 20 // ����� ������ � ������ ��� ����� ��������� (� ������������) static int RECEIVER_PIN; @@ -130,7 +133,7 @@ class Oregon_NR { public: - // + //������ ������� word sens_type; //Sensor type @@ -143,34 +146,34 @@ class Oregon_NR byte ver = 0; //Protocol version - bool crc_c = 0; //CRC check result. . . - bool captured = 0; //Capture data flag. , . + bool crc_c = 0; //CRC check result. ������������ ��� �������. ������������ ��� ����� ����������� ������. + bool captured = 0; //Capture data flag. ������������, ���� ���� ������� ������ � ������. unsigned long work_time; //Capture time byte packet[PACKET_LENGTH]; //Result packet - byte valid_p[PACKET_LENGTH]; //Validity mask - + byte valid_p[PACKET_LENGTH]; //Validity mask - ����� ���������� ������������� ����� byte packets_received = 0; //Number of received packets in block (0...2) - byte received_CRC; //Calculated RC + byte received_CRC; //Calculated �RC - Oregon_NR(byte, byte); //. : - Oregon_NR(byte, byte, byte, bool); //( , , , pull up) + Oregon_NR(byte, byte); //�����������. ���������: + Oregon_NR(byte, byte, byte, bool); //(����� ��������, ����� ����������, ����� ����������, pull up) void start(); //Star listening receiver - void stop(); //Stop listening receiver. , + void stop(); //Stop listening receiver. ����� �� ������� ���������, ����� �� ����� void capture(bool); //Capture packet. if parameter is true function dumps capture data to Serial. - bool consist_synchro = false; // ? + bool consist_synchro = false; //��� ������ ����������� ��������� ������������� ��� ������������ ������? - byte empty_space = 3; // "" ? - // . - // , . - // 5 - bool catch2 = 1, catch3 = 1; // - int timing_correction = 0; // ( -10 +10) - byte decode_method = 3; // - //1 - - //3 - - - // + byte empty_space = 3; //����� ���������� "������" ������ ����� ��� ����������� ����� �������? + //�������� ������������ ������� ������� � ��������� ��� ��������. + //��� ��� �����, ��� ������ �����. �� ������ ���� �� ������������� + //� ������ ������ ���� 5 + bool catch2 = 1, catch3 = 1; //����� ������ ��������� ��������� + int timing_correction = 0; //��������� ������� ����� (�� -10 �� +10) + byte decode_method = 3; // ����� ������������� ������ + //1 - ������������ + //3 - ��� �������� ������� + + //��������� float sens_avg_ws, sens_max_ws; byte sens_wdir; float get_avg_windspeed(byte*); @@ -180,32 +183,36 @@ class Oregon_NR byte UV_index, lightness; byte get_UV(byte*); byte get_light(byte*); + //Rain + float sens_total_rain, sens_rain_rate; + float get_total_rain(byte*); + float get_rain_rate(byte*); - byte restore_sign; // , + byte restore_sign; //������� ����, ������������ �� �������� �������� ����������� ������ - //0 - - //1 - - //2 - - //3 - (v2) - + //0 - ������������� ��������� ����� + //1 - ������������� ������� ����� + //2 - ����������� ������ ��������� ��� �������� ������ + //3 - ������������� ������� ���������� (v2) - ��������� ��� �������� �������� - bool receiver_dump = 0; // Serial. capture(true) - // - // + bool receiver_dump = 0; //���������� �� ���� ������ � Serial. �������� ������ ���� capture(true) + // ���������� ��� ������������� ��������� ������� � �������� + // ����� ��������� �������� ������������������ �� � ����� �������������� #if ADD_SENS_SUPPORT == 1 float sens_pressure, //Pressure - sens_voltage, // (for CURRENT THP sensors) + sens_voltage, // ���������� � � (for CURRENT � THP sensors) sens_tmp2; //Temperature2 (for GASv2 sensor) byte sens_CO, //CO (ppm*10) (for GASv2 sensor) sens_CH; //CH4 (ppm*100)(ppm) byte sens_ip22, //IP22 channel data (for FIRE sensor) sens_ip72, //IP72 channel data (for FIRE sensor) sens_lockalarm; //LOCK_ALARM channel data (for FIRE sensor) - float sens_current; // (for CURRENT sensor) + float sens_current; // ��� � � (for CURRENT sensor) - word sens_pump_count; // - unsigned long sens_drop_counter;// (for CAPRAIN sensor) - int sens_capacitance; // (for CAPRAIN sensor) + word sens_pump_count; // ������� ������ + unsigned long sens_drop_counter;// ������� ������ (for CAPRAIN sensor) + int sens_capacitance; //������� ������� (for CAPRAIN sensor) #endif @@ -213,39 +220,39 @@ class Oregon_NR byte read_tacts, read_tacts2, result_size; - byte LED = 0xFF; // , - bool PULL_UP; // - byte packet_number = 0; // - int INT_NO; // - //bool reciever_ctrl = true; // ( , ) - - // - byte decode_tacts[READ_BITS2]; // . - // 0= - // 1= - // 2= - // 3=+ - // 4=- - - byte collect_data[READ_BITS2], // + byte LED = 0xFF; //����� ����������, ������� ������ ��� ����� + bool PULL_UP; //���� ��������� ��������� + byte packet_number = 0; //���������� �������� ������� � ������� + int INT_NO; //����� ���������� �������� + //bool reciever_ctrl = true; //���� �������� �������� (������������ ��� ������� ��������, ������������ � �������) + + //������� ������ ��� ������ ������ � ������ � ���������� ����� + byte decode_tacts[READ_BITS2]; //������ ������. �������� + // 0=���� + // 1=������� + // 2=���������� + // 3=�������+ + // 4=�������- + + byte collect_data[READ_BITS2], //������ ��� ����� ������ � �������� #if IS_ASSEMBLE collect_data2[READ_BITS2]; #else collect_data2[1]; #endif - // , : - // 128 - - // >128 - - // <128 - + //� ����� ���������� �������� ���������� �����, �� �������� �����: + // 128 - ���������� + // >128 - ������� + // <128 - ���� byte receive_status = FIND_PACKET; byte start_pulse_cnt = 0; unsigned long pulse_length, timer_marklong; unsigned long pulse_marker, right_pulse_marker; - unsigned long pre_marker; // + unsigned long pre_marker; // ��� �������� ��������� ����� ��������� ��� ������� ������ unsigned long first_packet_end; - byte data_val, data_val2; // - byte synchro_pos, synchro_pos2; // + byte data_val, data_val2; // �������� ������� + byte synchro_pos, synchro_pos2; // ������� ������������ � ������ byte get_gas_CH(byte* gas_data); byte get_gas_CO(byte* gas_data); From 35735c40fe3a482f5e97baf12cec5eb2f0f67808 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fabian=20Gro=C3=9Fe?= Date: Mon, 30 Dec 2019 12:16:19 +0100 Subject: [PATCH 2/3] Fix English typos --- Oregon_NR.cpp | 2 +- Oregon_NR.h | 2 +- Oregon_TM.cpp | 54 +++++++++++++++++++++++++-------------------------- Oregon_TM.h | 40 +++++++++++++++++++------------------- README.md | 50 +++++++++++++++++++++++------------------------ 5 files changed, 74 insertions(+), 74 deletions(-) diff --git a/Oregon_NR.cpp b/Oregon_NR.cpp index 1364c0f..b69eb39 100644 --- a/Oregon_NR.cpp +++ b/Oregon_NR.cpp @@ -18,7 +18,7 @@ // UVN800, // PCR800. // -// Aslo supported self-developed sensors. Please contact author for additional infromation. +// Also supported self-developed sensors. Please contact author for additional information. // // This file is part of the Arduino OREGON_NR library. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/Oregon_NR.h b/Oregon_NR.h index 6725bf0..e1d5990 100644 --- a/Oregon_NR.h +++ b/Oregon_NR.h @@ -20,7 +20,7 @@ // UVN800, // PCR800. // -// Aslo supported self-developed sensors. Please contact author for additional infromation. +// Also supported self-developed sensors. Please contact author for additional information. // // This file is part of the Arduino OREGON_NR library. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/Oregon_TM.cpp b/Oregon_TM.cpp index b8b95ab..c44cd28 100644 --- a/Oregon_TM.cpp +++ b/Oregon_TM.cpp @@ -14,10 +14,10 @@ // Receive only: // THN132N, -// WGR800, +// WGR800, // UVN800. // -// Aslo supported self-developed sensors. Please contact author for additional infromation. +// Also supported self-developed sensors. Please contact author for additional information. // // This file is part of the Arduino OREGON_NR library. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -39,46 +39,46 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Oregon Scientific v2.1 v3.0 +// ������ ���������� ������� ������������� ��� ������ � �������� ������ � ������� ������������� ��������� Oregon Scientific v2.1 � v3.0 // -// 14 2019 +// ��������� ���������� 14 ������� 2019 // -// +// �������������� ������ ��������� �������� // -// : +// ���� � ��������: // THGN132N (THGR122N, THGN123N), // RTGN318, // THGR810. -// : +// ������ ����: // THN132N, // WGR800, // UVN800. // -// ( ) +// ����� �������������� ������� ����������� ���������� (�� �������������� ������������ ���������� � ������) // -// - OREGON_NR +// ���� ���� - ����� ���������� OREGON_NR ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Copyright (c) 2019 +// Copyright (c) 2019 ������ �������� // -// , -// ( ), , -// , , , , , , -// / , , , : +// ������ �������� ��������� �����, ���������� ����� ������� ������������ ����������� � ������������� ������������ +// (� ���������� ���������� ������������ �����������), ������������ ������������ ����������� ����������� ��� �����������, +// ������� �������������� ����� �� �������������, �����������, ���������, �������, ����������, ���������������, ����������������� +// �/��� ������� ����� ������������ �����������, � ����� �����, ������� ��������������� ������ ����������� �����������, ��� ���������� ��������� �������: // -// . +// ��������� ���� ����������� �� ��������� ����� � ������ ������� ������ ���� �������� �� ��� ����� ��� �������� ����� ������� ������������ �����������. // -// ܻ, - , , -// , , . -// - , , , , , -// - . +// ������ ����������� ����������� ��������������� ���� ���ܻ, ��� �����-���� ��������, ���� ���������� ��� ���������������, ������� �������� �������� +// �����������, ������������ �� ��� ����������� ���������� � ���������� ���������, �� �� ������������� ���. �� � ����� ������ ������ ��� ��������������� +// �� ����� ��������������� �� �����-���� �����, �� ����� ��� �� ���� �����������, � ��� �����, ��� �������� ���������, ������� ��� ���� ��������, +// ��������� ��-�� ������������� ������������ ����������� ��� ���� �������� � ����������� ������������. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// +//����������� Oregon_TM::Oregon_TM(byte tr_pin) { TX_PIN = tr_pin; @@ -95,7 +95,7 @@ Oregon_TM::Oregon_TM(void) /////////////////////////////////////////////////////////////////////////////////////////////////// -// //////////////////////////////////////////////////////////////////////////// +// ������� �����������//////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_TM::sendZero(void) { @@ -209,7 +209,7 @@ void Oregon_TM::sendMSB(byte data) (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 == 2) time_marker += timing_corrector2; //�������� �� ������� �������� ������ 1024.07�� � 1024.60�� if (protocol == 3) time_marker += timing_corrector3; @@ -222,7 +222,7 @@ void Oregon_TM::sendLSB(byte data) (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 == 2) time_marker += timing_corrector2; //�������� �� ������� �������� ������ 1024.07�� � 1024.60�� if (protocol == 3) time_marker += timing_corrector3; } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -234,9 +234,9 @@ void Oregon_TM::sendData() sendMSB(SendBuffer[i]); if (i < 9) sendLSB(SendBuffer[i]); - if (protocol == 2) time_marker += 4; // 1024.07 1024.60 + if (protocol == 2) time_marker += 4; //�������� �� ������� �������� ������ 1024.07�� � 1024.60�� //if (protocol == 3) time_marker += 4; - // 1024.07 1024 + //�������� �� ������� �������� ������ 1024.07�� � 1024�� } } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -409,7 +409,7 @@ void Oregon_TM::SendPacket() } /////////////////////////////////////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////////// +// ������� ����������� ������////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_TM::setType(word type) { @@ -645,7 +645,7 @@ bool Oregon_TM::transmit() /////////////////////////////////////////////////////////////////////////////////////////////////// -// THP +//��������� ������� THP /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/Oregon_TM.h b/Oregon_TM.h index 44f9fa6..fe7ff9b 100644 --- a/Oregon_TM.h +++ b/Oregon_TM.h @@ -16,10 +16,10 @@ // Receive only: // THN132N, -// WGR800, +// WGR800, // UVN800. // -// Aslo supported self-developed sensors. Please contact author for additional infromation. +// Also supported self-developed sensors. Please contact author for additional information. // // This file is part of the Arduino OREGON_NR library. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -41,40 +41,40 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Oregon Scientific v2.1 v3.0 +// ������ ���������� ������� ������������� ��� ������ � �������� ������ � ������� ������������� ��������� Oregon Scientific v2.1 � v3.0 // -// 14 2019 +// ��������� ���������� 14 ������� 2019 // -// +// �������������� ������ ��������� �������� // -// : +// ���� � ��������: // THGN132N (THGR122N, THGN123N), // RTGN318, // THGR810. -// : +// ������ ����: // THN132N, // WGR800, // UVN800. // -// ( ) +// ����� �������������� ������� ����������� ���������� (�� �������������� ������������ ���������� � ������) // -// - OREGON_NR +// ���� ���� - ����� ���������� OREGON_NR ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Copyright (c) 2019 +// Copyright (c) 2019 ������ �������� // -// , -// ( ), , -// , , , , , , -// / , , , : +// ������ �������� ��������� �����, ���������� ����� ������� ������������ ����������� � ������������� ������������ +// (� ���������� ���������� ������������ �����������), ������������ ������������ ����������� ����������� ��� �����������, +// ������� �������������� ����� �� �������������, �����������, ���������, �������, ����������, ���������������, ����������������� +// �/��� ������� ����� ������������ �����������, � ����� �����, ������� ��������������� ������ ����������� �����������, ��� ���������� ��������� �������: // -// . +// ��������� ���� ����������� �� ��������� ����� � ������ ������� ������ ���� �������� �� ��� ����� ��� �������� ����� ������� ������������ �����������. // -// ܻ, - , , -// , , . -// - , , , , , -// - . +// ������ ����������� ����������� ��������������� ���� ���ܻ, ��� �����-���� ��������, ���� ���������� ��� ���������������, ������� �������� �������� +// �����������, ������������ �� ��� ����������� ���������� � ���������� ���������, �� �� ������������� ���. �� � ����� ������ ������ ��� ��������������� +// �� ����� ��������������� �� �����-���� �����, �� ����� ��� �� ���� �����������, � ��� �����, ��� �������� ���������, ������� ��� ���� ��������, +// ��������� ��-�� ������������� ������������ ����������� ��� ���� �������� � ����������� ������������. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -149,4 +149,4 @@ class Oregon_TM }; #endif - + diff --git a/README.md b/README.md index d3b7e0f..946e025 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // This Arduino code is for receive and transmit data using Oregon Scientific RF protocol version 2.1 and 3.0. // -// Last updated: 14 ctober 2019 +// Last updated: 14 October 2019 // // The folowed sensors data format are supported. // @@ -13,46 +13,46 @@ // Receive only: // THN132N, -// WGR800, +// WGR800, // UVN800. // -// Aslo supported self-developed sensors. Please contact author for additional infromation. +// Also supported self-developed sensors. Please contact author for additional information. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Oregon Scientific v2.1 v3.0 +// ������ ���������� ������� ������������� ��� ������ � �������� ������ � ������� ������������� ��������� Oregon Scientific v2.1 � v3.0 // -// 14 2019 +// ��������� ���������� 14 ������� 2019 // -// +// �������������� ������ ��������� �������� // -// : +// ���� � ��������: // THGN132N (THGR122N, THGN123N), // RTGN318, // THGR810. -// : +// ������ ����: // THN132N, -// WGR800, +// WGR800, // UVN800. // -// ( ) +// ����� �������������� ������� ����������� ���������� (�� �������������� ������������ ���������� � ������) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// THGN132N, THN132N WGR800. +// ��� �������� ������������� �� ������������ �������� THGN132N, THN132N � WGR800. // -// BAR206, BAR208 THGN132N -// : -// 2-98% -// -50...+70 -// " " , -// +-1. THGN132: -// 1 - 39 (38 - 40) c -// 2 - 41 (40 - 42) c -// 3 - 43 (42 - 44) c +// ��� ����������� ��������������� �� �������� �������� BAR206, BAR208 ��������� ������� THGN132N +// ��� ��������� ����� �������� �������� ������� ���������� ��������� ��������� ������� ��� �������� ������: +// ��������� 2-98% +// ����������� -50...+70� +// ��� �������� ����������������� �������� � ������� "��������� ���" ����� ������, ��� ��������� ����� �������� ��� ��������� ����� �������� �������� +// ������ ���������� �� ����������� �� ����� ��� �� +-1���. �������� ��� THGN132: +// ����� 1 - 39 (38 - 40) c +// ����� 2 - 41 (40 - 42) c +// ����� 3 - 43 (42 - 44) c // -// CRC , , +3.0 0300, A200 -// ID . -// ID . +// ���� ������ ����� � ���������� CRC � ����������� ������, �� �������� ����������� � ��������� ������������, �������� +3.0� �������� �� ��� 0300, � A200 +// �� ������ ����� ���� ������������ �� ����� ID ��� �� ������ �������� ��������. +// ���������� �������� �������� � ��� ������������ ��������� ������ ������ � ID �������. ���� ������ ���� �� ����� �� ������ // -// RTGN318 THGR810 . -// \ No newline at end of file +// �������� �������� � ������� RTGN318 � THGR810 �� ����� �� ��������������. ������� �������� �������� � ������ ���� �������� �������� �������� +// �� ��������� ������� From 9f546dc3868c953bbede8c99ee753b9c4c9d7978 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fabian=20Gro=C3=9Fe?= Date: Mon, 30 Dec 2019 13:50:30 +0100 Subject: [PATCH 3/3] Fix Cyrillic characters --- LICENSE.md | 20 +- Oregon_NR.cpp | 529 +++++++++++++++++++++--------------------- Oregon_NR.h | 297 ++++++++++++------------ Oregon_TM.cpp | 619 ++++++++++++++++++++++++-------------------------- Oregon_TM.h | 67 +++--- README.md | 70 +++--- 6 files changed, 785 insertions(+), 817 deletions(-) diff --git a/LICENSE.md b/LICENSE.md index f975535..bb65bb3 100644 --- a/LICENSE.md +++ b/LICENSE.md @@ -17,17 +17,17 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Copyright (c) 2019 +// Copyright (c) 2019 Се гей Зависляк // -// , -// ( ), , -// , , , , , , -// / , , , : +// Данная лицензия аз ешает лицам, получившим копи данного п ог аммного обеспечения и сопутству щей документации +// (в дальнейшем именуемыми «П ог аммное Обеспечение»), безвозмездно использовать П ог аммное Обеспечение без ог аничений, +// вкл чая неог аниченное п аво на использование, копи ование, изменение, слияние, публикаци , асп ост анение, сублицензи ование +// и/или п одажу копий П ог аммного Обеспечения, а также лицам, кото ым п едоставляется данное П ог аммное Обеспечение, п и собл дении следу щих условий: // -// . +// Указанное выше уведомление об авто ском п аве и данные условия должны быть вкл чены во все копии или значимые части данного П ог аммного Обеспечения. // -// ܻ, - , , -// , , . -// - , , , , , -// - . +// ДАННОЕ П ОГ АММНОЕ ОБЕСПЕЧЕНИЕ П ЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО ГА АНТИЙ, ЯВНО ВЫ АЖЕННЫХ ИЛИ ПОД АЗУМЕВАЕМЫХ, ВКЛ ЧАЯ ГА АНТИИ ТОВА НОЙ +// П ИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНК ЕТНОМУ НАЗНАЧЕНИ И ОТСУТСТВИЯ НА УШЕНИЙ, НО НЕ ОГ АНИЧИВАЯСЬ ИМИ. НИ В КАКОМ СЛУЧАЕ АВТО Ы ИЛИ П АВООБЛАДАТЕЛИ +// НЕ НЕСУТ ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА УЩЕ Б ИЛИ ПО ИНЫМ Т ЕБОВАНИЯМ, В ТОМ ЧИСЛЕ, П И ДЕЙСТВИИ КОНТ АКТА, ДЕЛИКТЕ ИЛИ ИНОЙ СИТУАЦИИ, +// ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ П ОГ АММНОГО ОБЕСПЕЧЕНИЯ ИЛИ ИНЫХ ДЕЙСТВИЙ С П ОГ АММНЫМ ОБЕСПЕЧЕНИЕМ. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/Oregon_NR.cpp b/Oregon_NR.cpp index b69eb39..e6821d3 100644 --- a/Oregon_NR.cpp +++ b/Oregon_NR.cpp @@ -40,45 +40,43 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// ������ ���������� ������� ������������� ��� ������ � �������� ������ � ������� ������������� ��������� Oregon Scientific v2.1 � v3.0 +// Данная библиотека Ардуино предназначена для приема и передачи данных в формате беспроводного протокола Oregon Scientific v2.1 и v3.0 // -// ��������� ���������� 14 ������� 2019 +// Последнее обновление 29 июня 2019 // -// �������������� ������ ��������� �������� +// Поддерживается формат следующих датчиков // -// ���� � ��������: +// Приём и передача: // THGN132N (THGR122N, THGN123N), // RTGN318, // THGR810. -// ������ ����: +// Тольок приём: // THN132N, // WGR800, -// UVN800, // PCR800. // -// ����� �������������� ������� ����������� ���������� (�� �������������� ������������ ���������� � ������) +// Также поддерживаются датчики собственной разработки (за дополнительной документацей обращаться к автору) // -// ���� ���� - ����� ���������� OREGON_NR +// Этот файл - часть библиотеки OREGON_NR ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Copyright (c) 2019 ������ �������� +// Copyright (c) 2019 Сергей Зависляк // -// ������ �������� ��������� �����, ���������� ����� ������� ������������ ����������� � ������������� ������������ -// (� ���������� ���������� ������������ �����������), ������������ ������������ ����������� ����������� ��� �����������, -// ������� �������������� ����� �� �������������, �����������, ���������, �������, ����������, ���������������, ����������������� -// �/��� ������� ����� ������������ �����������, � ����� �����, ������� ��������������� ������ ����������� �����������, ��� ���������� ��������� �������: +// Данная лицензия разрешает лицам, получившим копию данного программного обеспечения и сопутствующей документации +// (в дальнейшем именуемыми «Программное Обеспечение»), безвозмездно использовать Программное Обеспечение без ограничений, +// включая неограниченное право на использование, копирование, изменение, слияние, публикацию, распространение, сублицензирование +// и/или продажу копий Программного Обеспечения, а также лицам, которым предоставляется данное Программное Обеспечение, при соблюдении следующих условий: // -// ��������� ���� ����������� �� ��������� ����� � ������ ������� ������ ���� �������� �� ��� ����� ��� �������� ����� ������� ������������ �����������. +// Указанное выше уведомление об авторском праве и данные условия должны быть включены во все копии или значимые части данного Программного Обеспечения. // -// ������ ����������� ����������� ��������������� ���� ���ܻ, ��� �����-���� ��������, ���� ���������� ��� ���������������, ������� �������� �������� -// �����������, ������������ �� ��� ����������� ���������� � ���������� ���������, �� �� ������������� ���. �� � ����� ������ ������ ��� ��������������� -// �� ����� ��������������� �� �����-���� �����, �� ����� ��� �� ���� �����������, � ��� �����, ��� �������� ���������, ������� ��� ���� ��������, -// ��������� ��-�� ������������� ������������ ����������� ��� ���� �������� � ����������� ������������. +// ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ +// ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ +// НЕ НЕСУТ ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА УЩЕРБ ИЛИ ПО ИНЫМ ТРЕБОВАНИЯМ, В ТОМ ЧИСЛЕ, ПРИ ДЕЙСТВИИ КОНТРАКТА, ДЕЛИКТЕ ИЛИ ИНОЙ СИТУАЦИИ, +// ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -//��, ��� ��������� � ����������///////////////////////////////////// +//Всё, что относится к прерыванию///////////////////////////////////// #ifndef Oregon_NR_int #define Oregon_NR_int static volatile unsigned long pm; @@ -93,14 +91,14 @@ void receiver_interruption(void) { #endif if(digitalRead(RECEIVER_PIN)){ - //������ �������� + //Начало импульса pl = 0; pm = micros(); } else{ - //����� �������� - //����������� ����� ��������� � ����� - pl = micros() - pm; + //Конец импульса + //Вычисляется время окончания и длина + pl = micros() - pm; //pm += pl; } //yield(); @@ -112,7 +110,7 @@ Oregon_NR::Oregon_NR(byte MHZ, byte MHZ_INT) { INT_NO = MHZ_INT; RECEIVER_PIN = MHZ; - pinMode(MHZ, INPUT); // �����, �� ������� ��������� ������� + pinMode(MHZ, INPUT); // Вывод, на который подключён приёмник } Oregon_NR::Oregon_NR(byte MHZ, byte MHZ_INT, byte led, bool pull_up) @@ -121,8 +119,8 @@ Oregon_NR::Oregon_NR(byte MHZ, byte MHZ_INT, byte led, bool pull_up) LED = led; PULL_UP = pull_up; RECEIVER_PIN = MHZ; - pinMode(MHZ, INPUT); // �����, �� ������� ��������� ������� - pinMode(LED, OUTPUT); // ����� ���������� + pinMode(MHZ, INPUT); // Вывод, на который подключён приёмник + pinMode(LED, OUTPUT); // Вывод светодиода } ////////////////////////////////////////////////////////////////////// @@ -141,13 +139,13 @@ void Oregon_NR::stop() detachInterrupt(INT_NO); } ////////////////////////////////////////////////////////////////////// -//������ � ������ ������ -//DEBUG_INFO - � Serial ��������� ���������� � ������� ������ +//Захват и анализ пакета +//DEBUG_INFO - в Serial выводится информация о захвате данных ////////////////////////////////////////////////////////////////////// void Oregon_NR::capture(bool DEBUG_INFO) { //////////////////////////////////////////////////////// - // ������������ � ��������� ��������� + // Возвращаемся к исходному состоянию //maybe_packet = 0; packets_received = 0; sens_type = 0; @@ -158,7 +156,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) //////////////////////////////////////////////////////// - //������ ������ � �������� + //Чтение данных с приёмника noInterrupts(); pulse_length = pl; pl = 0; @@ -166,15 +164,14 @@ void Oregon_NR::capture(bool DEBUG_INFO) interrupts(); //////////////////////////////////////////////////////// - //������ ������� - if (pulse_length != 0 && receive_status == FIND_PACKET){ - //���� ������� ������ ������� ������ ��� ���������� ������ ���������, �� ��� ������ ������� + //Пришёл импульс + if (pulse_length != 0 && receive_status == FIND_PACKET){ if (pulse_marker - pre_marker > (PER_LENGTH2 * 2 + LENGTH_TOLERANCE) && ver == 2) start_pulse_cnt = 0; if (pulse_marker - pre_marker > (PER_LENGTH3 * 2 + LENGTH_TOLERANCE) && ver == 3) start_pulse_cnt = 0; if (start_pulse_cnt == 0){ //////////////////////////////////////////////////////// - //������� ������ "����������" ������� - ���������� ��� ��������� + //Найдена первый "правильный" импульс - определяем тип протокола if (pulse_length < (MAX_LENGTH2 + LENGTH_TOLERANCE) && pulse_length > (MIN_LENGTH2 - LENGTH_TOLERANCE) && catch2 ) { start_pulse_cnt++; pre_marker = pulse_marker; @@ -191,10 +188,10 @@ void Oregon_NR::capture(bool DEBUG_INFO) } else{ /////////////////////////////////////////////////////////// - //������� ��������� "����������" ������� + //Найдена следующий "правильный" импульс if (pulse_length <= (MAX_LENGTH2 + LENGTH_TOLERANCE) && pulse_length >= (MIN_LENGTH2 - LENGTH_TOLERANCE) && catch2) { /////////////////////////////////////////////////////////// - //���� ������� � ���������� �����, �� ��������� ������� �������� ��������� ��������� + //Если импульс в правильном месте, то добавляем счётчик найденых стартовых импульсов if(pulse_marker - pre_marker > (PER_LENGTH2*2-LENGTH_TOLERANCE) && pulse_marker - pre_marker < (PER_LENGTH2 * 2 + LENGTH_TOLERANCE) && ver == 2) { start_pulse_cnt++; @@ -202,8 +199,8 @@ void Oregon_NR::capture(bool DEBUG_INFO) pulse_length = 0; } /////////////////////////////////////////////////////////// - //��������� ������� ��������� � ������������ ����� - //��������� ��� ������ + //Следующий импульс находится в неправильном месте + //Назначаем его первым else { start_pulse_cnt = 1; @@ -215,7 +212,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) if (pulse_length <= (MAX_LENGTH3 + LENGTH_TOLERANCE) && pulse_length >= (MIN_LENGTH3 - LENGTH_TOLERANCE) && catch3) { /////////////////////////////////////////////////////////// - //���� ������� � ���������� �����, �� ��������� ������� �������� ��������� ��������� + //Если импульс в правильном месте, то добавляем счётчик найденых стартовых импульсов if(pulse_marker - pre_marker > (PER_LENGTH3*2-LENGTH_TOLERANCE) && pulse_marker - pre_marker < (PER_LENGTH3 * 2 + LENGTH_TOLERANCE) && ver == 3) { start_pulse_cnt++; @@ -223,8 +220,8 @@ void Oregon_NR::capture(bool DEBUG_INFO) pulse_length = 0; } /////////////////////////////////////////////////////////// - //��������� ������� ��������� � ������������ ����� - //��������� ��� ������ + //Следующий импульс находится в неправильном месте + //Назначаем его первым else { start_pulse_cnt = 1; @@ -237,15 +234,15 @@ void Oregon_NR::capture(bool DEBUG_INFO) } //************************************************************************************* ///////////////////////////////////////////////////////////////////// - // ���� ������ ������ ����� � ����� ����� �������� ������� - // �� ��� �������, � �������� � ����� ������� - // ����� �� ��� ������� ������ ���� �������� ����� ���������� ������� + // Если найден первый пакет и вышло вермя ожидания второго + // Не ждём второго, а переходм в режим анализа + // тАКЖЕ не ждём второго пакета если отключён режим сращивания пакетов if (packet_number == 1 && (millis() - first_packet_end) > 200) receive_status = ANALIZE_PACKETS; if (packet_number == 1 && (!IS_ASSEMBLE || ver == 3 )) receive_status = ANALIZE_PACKETS; ////////////////////////////////////////////////////////////////////// - //���� ������� ������ ���������� ���������� ��������� � ������ ������, �� �������� ��� �����. �������� ���� ������ + //Если Найдено нужное количество правильных импульсов в нужных местах, то возможно это пакет. Начинаем СБОР ДАННЫХ if (start_pulse_cnt == CATCH_PULSES && receive_status == FIND_PACKET) { @@ -265,27 +262,27 @@ void Oregon_NR::capture(bool DEBUG_INFO) } } ////////////////////////////////////////////////////////////////////// - // ������ ������//////////////////////////////////////////////////////// - if (receive_status == ANALIZE_PACKETS) { + // Анализ данных//////////////////////////////////////////////////////// + if (receive_status == ANALIZE_PACKETS) { ////////////////////////////////////////////////////////////////////// - //���� ������ ������ ����� �������, �� �� ����� � ������������ - if ((ver ==2 && read_tacts < 136 && read_tacts2 < 136) || (ver ==3 && read_tacts < 80)) + //Если пришёл тольок кусок посылки, то не стоит и обрабатывать + if ((ver ==2 && read_tacts < 136 && read_tacts2 < 136) || (ver ==3 && read_tacts < 80)) { receive_status = FIND_PACKET; - start_pulse_cnt = 0; + start_pulse_cnt = 0; packet_number = 0; return; } - //��������� ����������, ����� ��������� ����� ��������� + //Отключаем прерывание, чтобы сократить время обработки detachInterrupt(INT_NO); led_light(true); restore_sign = 0; - work_time = millis(); //������ ������� ��������� ������ - //���� ��������� ������ - //��� ������� ��� ����� �������� ��������� ����� ���� �������� - // v2 - 87 07 � ������� 86 06, �.�. ����� �������� 883�� � 395�� - // v3 - 86 06 � ������� 87 07 �.�. ����� �������� 838 � 350�� + work_time = millis(); + //Дамп собранных данных + //ДЛя посылки без помех значения имурльсов олжны быть примерно + // v2 - 87 07 и изредка 86 06, т.к. длина импульса 883мс и 395мс + // v3 - 86 06 и изредка 87 07 т.к. длина импульса 838 и 350мс if (DEBUG_INFO && receiver_dump){ Serial.println(" "); Serial.print("SCOPE1 "); @@ -310,8 +307,8 @@ void Oregon_NR::capture(bool DEBUG_INFO) ////////////////////////////////////////////// - //��������� ������ ������ - //�������������� ������. ������ ��������� � decode_tacts[] + //Обработка первой записи + //Расшифровываем запись. Данные сохраянем в decode_tacts[] get_tacts(collect_data, read_tacts); bool halfshift; @@ -324,10 +321,10 @@ void Oregon_NR::capture(bool DEBUG_INFO) halfshift = 1; } ////////////////////////////////////////////// - //���� ������� ����������� + //Ищем позицию синхронибла synchro_pos = get_synchro_pos(collect_data); ////////////////////////////////////////////// - //������� ������� + //Выводим посылку if (DEBUG_INFO){ if (packet_number == 2) Serial.print("1) "); if (packet_number == 1) Serial.print("RESULT "); @@ -338,8 +335,8 @@ void Oregon_NR::capture(bool DEBUG_INFO) if (collect_data[bt] == 128 + 1) Serial.print('i'); if (collect_data[bt] == 128 - 1) Serial.print('o'); if (collect_data[bt] == 128) Serial.print('.'); - if (receiver_dump && ver == 2) Serial.print(" "); - if (receiver_dump && ver == 3) Serial.print(" "); + if (receiver_dump && ver == 2) Serial.print(" "); + if (receiver_dump && ver == 3) Serial.print(" "); } else Serial.print(' '); } @@ -353,7 +350,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) Serial.println (millis() / 1000); } ////////////////////////////////////////////// - //���������� ������������ ������ ������ + //Аналогично обрабатываем вторую запись if (packet_number == 2){ get_tacts(collect_data2, read_tacts2); @@ -397,12 +394,12 @@ void Oregon_NR::capture(bool DEBUG_INFO) ////////////////////////////////////////////// - //������������� ������� - //���� ����� ����, �� � ������������ �� �� ���� + //СОПОСТАВЛЕНИЕ ПАКЕТОВ + //Если пакет один, то и сопоставлять не из чего if (packet_number == 1) result_data = collect_data; ////////////////////////////////////////////// - //� ��� ���� ���, �� ����� ������ ������ - //��������� ����������� "��������" ������� ���� ������������ ����� + //А вот если два, то нужна СБОРКА ПАКЕТА + //вычисляем оптимальное "смещение" пакетов друг относительно друга if (packet_number == 2) { correlation = correlate_data(collect_data, collect_data2); if (DEBUG_INFO){ @@ -410,7 +407,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) Serial.println(correlation); } ////////////////////////////////////////////// - //�������� ������ � �����, ��� ���������� ������ ������ + //Собираем данные в пакет, где синхронибл найден раньше ////////////////////////////////////////////// if (synchro_pos >= synchro_pos2) @@ -428,7 +425,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) } } ////////////////////////////////////////////// - //����� ������� ������� + //Вывод готовой посылки if (DEBUG_INFO && packet_number == 2){ Serial.print("RESULT "); byte* rdt = result_data; @@ -450,7 +447,7 @@ void Oregon_NR::capture(bool DEBUG_INFO) - //���������, ���� �� ���-������ ���������� - ��������. ��� ��� ����� ���� ����, �� �������� ����� ������� + //Проверяем, дало ли что-нибудь сращивание - отключил. Это даёт всего лишь флаг, но занимает много времени ////////////////////////////////////////////// // if (get_data(halfshift, ver, result_data) > data_val && get_data(halfshift, ver, result_data) > data_val2 && ver == 2) @@ -461,20 +458,20 @@ void Oregon_NR::capture(bool DEBUG_INFO) sens_type = 0; if (get_info_data(result_data, packet, valid_p)) { - sens_type = get_sensor(packet); //���������� ��� ������ �� ���� ������� - restore_data(packet, sens_type); // ��������������� ������ �� ���� ������� - crc_c = check_CRC(packet, sens_type); // ��������� CRC, ���� ��� �����, �� ��� ������������ ���� ������ ���������� - //���� �� ��� ����� ���������� ��������, ������ �������, ��� ����� ���������� + sens_type = get_sensor(packet); //Определяем тип пакета по типу датчика + restore_data(packet, sens_type); // Восстанавливаем данные по типу датчика + crc_c = check_CRC(packet, sens_type); // Проверяем CRC, если оно верно, то все сомнительные биты делаем уверенными + //Если не все байты определены уверенно, нельзя считать, что пакет корректный byte secresingV; if (sens_type == THGN132 || (sens_type & 0xFF00) == GAS) secresingV = PACKET_LENGTH - 4; if (sens_type == THN132) secresingV = PACKET_LENGTH - 6; for (byte www = 0; www < (PACKET_LENGTH - secresingV + 2); www++) if (valid_p[www] < 0x0f) crc_c = false; - //������ ������ ���������� ������ � ������, ���� ������� ��������� ������������������ (���� �������������) - //���� �� ���� ������������ - �� �� � ��� ������ ������������� + //Захват пакета происходит тольок в случае, если найдена стартовая последовательность (нибл синхронизации) + //Если не было синхрониблов - то не о чем вообще разговаривать if ( synchro_pos != 255 && packet_number == 1) captured = 1; if ( (synchro_pos2 != 255 || synchro_pos2 != 255) && packet_number == 2) captured = 1; - //������ ����� ������� �� ��������� + //Захват куска посылки не считается if ((ver ==2 && read_tacts < 136) || (ver ==3 && read_tacts < 80)) captured = 0; } // else if (data_val >=64 || data_val2 >=64) maybe_packet = 1; @@ -505,8 +502,8 @@ void Oregon_NR::capture(bool DEBUG_INFO) sens_wdir = 0; //////////////////////////////////////////////////////////////////////////////////////////////////// -//����������� �������� ������ -//////////////////////////////////////////////////////////////////////////////////////////////////// +//Расшифровка датчиков Орегон +//////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type == THGN132 || sens_type == THN132 || (sens_type & 0x0FFF)== RTGN318 || sens_type == THGR810) && crc_c){ sens_id = get_id(packet); @@ -543,8 +540,8 @@ if (sens_type == PCR800 && crc_c){ #if ADD_SENS_SUPPORT == 1 ////////////////////////////////////////////////////////////////////////////////////////////////// -//����������� ����������� ������� �������� -//////////////////////////////////////////////////////////////////////////////////////////////////// +//Расшифровка комплексных газовых датчиков +//////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type & 0xFF00) == GAS && crc_c){ sens_id = 0; sens_battery = 0; @@ -558,8 +555,8 @@ if (sens_type == PCR800 && crc_c){ sens_CH = get_gas_CH(packet); } ////////////////////////////////////////////////////////////////////////////////////////////////// -//����������� �������� �������� ������������ -//////////////////////////////////////////////////////////////////////////////////////////////////// +//Расшифровка датчиков пожарной сигнализации +//////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type & 0xFF00) == FIRE && crc_c){ sens_id = 0; sens_battery = 0; @@ -570,8 +567,8 @@ if (sens_type == PCR800 && crc_c){ sens_lockalarm = get_fire_lockalarm(packet); } ////////////////////////////////////////////////////////////////////////////////////////////////// -//����������� �������� THP -//////////////////////////////////////////////////////////////////////////////////////////////////// +//Расшифровка датчиков THP +//////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type & 0xFF00) == THP && crc_c){ sens_chnl = get_gas_channel(packet); sens_voltage = get_thp_voltage(packet); @@ -581,7 +578,7 @@ if (sens_type == PCR800 && crc_c){ } ////////////////////////////////////////////////////////////////////////////////////////////////// -//����������� �������� ���� � ���������� +//Расшифровка датчиков тока и напряжения //////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type & 0xFF00) == CURRENT && crc_c){ sens_id = 0; @@ -594,7 +591,7 @@ if (sens_type == PCR800 && crc_c){ } ////////////////////////////////////////////////////////////////////////////////////////////////// -//����������� �������� ������� ���������� ���� +//Расшифровка датчиков осадков емкостного типа //////////////////////////////////////////////////////////////////////////////////////////////////// if ((sens_type & 0xFF00) == CAPRAIN && crc_c){ sens_id = 0; @@ -607,8 +604,8 @@ if (sens_type == PCR800 && crc_c){ #endif //////////////////////////////////////////////////////////////////////////////// -//��������� ���������� -//���������� �� � �������� ��������� � �������� ������������� �������� +//Остальные вычисления +//Возвращаем всё в исходное состояние и включаем прослушивание приёмника work_time = millis() - work_time; packets_received = 0; if (data_val >= 64 && synchro_pos != 255) packets_received++; @@ -623,32 +620,31 @@ if (sens_type == PCR800 && crc_c){ } } //////////////////////////////////////////////////////////////////////////////////////////////////// -//��������� �� ������ �������� ������������������ -//���������: cdptr - ��������� �� ���������� �������� ������������������ -//��������� ������� � ������ decode_tacts +//Извлекает из записи тактовую последовательности +//Параметры: cdptr - указатель на записанную тактовую последовательность //////////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ -//����� �������� - for(int bt = 0 ; bt < bitsize; bt++) decode_tacts[bt] = 2; //���������� ���� ���������� + //Сброс массивов + for(int bt = 0 ; bt < bitsize; bt++) decode_tacts[bt] = 2; //Изначально такт неизвестен -//����������� ������ - byte* cdp = cdptr; + //Расшифровка тактов + byte* cdp = cdptr; for(int bt = 0 ; bt < bitsize; bt++) { if (ver == 2 && decode_method == 1) { - if ((*cdp & 0xf0) > 0x20 && (*cdp & 0x0f) > 0x03) decode_tacts[bt] = 1; - if ((*cdp & 0xf0) < 0x30 && (*cdp & 0x0f) < 0x05) decode_tacts[bt] = 0; - if ((*cdp & 0xf0) < 0x20 && (*cdp & 0x0f) > 0x04) decode_tacts[bt] = 4; - if ((*cdp & 0xf0) > 0x40 && (*cdp & 0x0f) < 0x02) decode_tacts[bt] = 3; + if ((*cdp & 0xf0) > 0x20 && (*cdp & 0x0f) > 0x03) decode_tacts[bt] = 1; // Такт 11 (В ИДЕАЛЕ 87, НО ИЗ ЗА СДВИГА НА 3 ТАКТА МОЖЕТ БЫТЬ ОТ 58 ДА 84) + if ((*cdp & 0xf0) < 0x30 && (*cdp & 0x0f) < 0x05) decode_tacts[bt] = 0; // Такт 00 (В ИДЕАЛЕ 00, НО ИЗ ЗА СДВИГА НА 3 ТАКТА МОЖЕТ БЫТЬ ОТ 30 ДА 03) + if ((*cdp & 0xf0) < 0x20 && (*cdp & 0x0f) > 0x04) decode_tacts[bt] = 4; // Такт 01 (В ИДЕАЛЕ 07, НО ИЗ ЗА СДВИГА НА 3 ТАКТА МОЖЕТ БЫТЬ ДО 34) + if ((*cdp & 0xf0) > 0x40 && (*cdp & 0x0f) < 0x02) decode_tacts[bt] = 3; // Такт 10 (В ИДЕАЛЕ 70, НО ИЗ ЗА СДВИГА НА 3 ТАКТА МОЖЕТ БЫТЬ ДО 43) } if (ver == 2 && decode_method == 2) { - if (*cdp == 0x88 || *cdp == 0x87 || *cdp == 0x86 || *cdp == 0x85 || *cdp == 0x84 || *cdp == 0x83 || *cdp == 0x78 || *cdp == 0x77 || *cdp == 0x68 || *cdp == 0x58 ) decode_tacts[bt] = 1; // ���� 11 (� ������ 87, �� �� �� ������ �� 3 ����� ����� ���� �� 58 � 84) - if (*cdp == 0x00 || *cdp == 0x01 || *cdp == 0x02 || *cdp == 0x03 || *cdp == 0x10 || *cdp == 0x20 || *cdp == 0x30) decode_tacts[bt] = 0; // ���� 00 (� ������ 00, �� �� �� ������ �� 3 ����� ����� ���� �� 30 �� 03) - if (*cdp == 0x05 || *cdp == 0x06 || *cdp == 0x07 || *cdp == 0x08 || *cdp == 0x15 || *cdp == 0x16 || *cdp == 0x17 || *cdp == 0x24 || *cdp == 0x25 || *cdp == 0x34 || *cdp == 0x35) decode_tacts[bt] = 4; // ���� 01 (� ������ 07, �� �� �� ������ �� 3 ����� ����� ���� �� 34) - if (*cdp == 0x50 || *cdp == 0x60 || *cdp == 0x70 || *cdp == 0x80 || *cdp == 0x51 || *cdp == 0x61 || *cdp == 0x71 || *cdp == 0x42 || *cdp == 0x52 || *cdp == 0x43 || *cdp == 0x53) decode_tacts[bt] = 3; // ���� 10 (� ������ 70, �� �� �� ������ �� 3 ����� ����� ���� �� 43) + if (*cdp == 0x88 || *cdp == 0x87 || *cdp == 0x86 || *cdp == 0x85 || *cdp == 0x84 || *cdp == 0x83 || *cdp == 0x78 || *cdp == 0x77 || *cdp == 0x68 || *cdp == 0x58 ) decode_tacts[bt] = 1; // Такт 11 (В ИДЕАЛЕ 87, НО ИЗ ЗА СДВИГА НА 3 ТАКТА МОЖЕТ БЫТЬ ОТ 58 ДА 84) + if (*cdp == 0x00 || *cdp == 0x01 || *cdp == 0x02 || *cdp == 0x03 || *cdp == 0x10 || *cdp == 0x20 || *cdp == 0x30) decode_tacts[bt] = 0; // Такт 00 (В ИДЕАЛЕ 00, НО ИЗ ЗА СДВИГА НА 3 ТАКТА МОЖЕТ БЫТЬ ОТ 30 ДА 03) + if (*cdp == 0x05 || *cdp == 0x06 || *cdp == 0x07 || *cdp == 0x08 || *cdp == 0x15 || *cdp == 0x16 || *cdp == 0x17 || *cdp == 0x24 || *cdp == 0x25 || *cdp == 0x34 || *cdp == 0x35) decode_tacts[bt] = 4; // Такт 01 (В ИДЕАЛЕ 07, НО ИЗ ЗА СДВИГА НА 3 ТАКТА МОЖЕТ БЫТЬ ДО 34) + if (*cdp == 0x50 || *cdp == 0x60 || *cdp == 0x70 || *cdp == 0x80 || *cdp == 0x51 || *cdp == 0x61 || *cdp == 0x71 || *cdp == 0x42 || *cdp == 0x52 || *cdp == 0x43 || *cdp == 0x53) decode_tacts[bt] = 3; // Такт 10 (В ИДЕАЛЕ 70, НО ИЗ ЗА СДВИГА НА 3 ТАКТА МОЖЕТ БЫТЬ ДО 43) } if (ver == 3 && decode_method == 1) { @@ -680,7 +676,7 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ *cdp++; } -// ������ ����������� + // Печать расшифорвки if (receiver_dump) { byte* cdp = cdptr; @@ -703,45 +699,45 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ } -// ������������ ��, ��� ������ � ���� -//��������� ��������� �� �������� ������������������ +// Расшифровали всё, что смогли с ходу +//Проверяем допустима ли тактовая последовательность for(int bt = 1; bt < bitsize; bt++) { // if (decode_tacts[bt] == 2) { - //�0 0X - ����������� + //Х0 0X - недопустима if ((decode_tacts[bt - 1] == 0 || decode_tacts[bt - 1] == 3) && (decode_tacts[bt] == 0 || decode_tacts[bt] == 4)) decode_tacts[bt] = 2; - //�1 1X - ����������� + //Х1 1X - недопустима if ((decode_tacts[bt - 1] == 1 || decode_tacts[bt - 1] == 4) && (decode_tacts[bt] == 1 || decode_tacts[bt] == 3)) decode_tacts[bt] = 2; } } -//�������������� ��������� ������ +//Восстановление одиночных тактов for(int bt = 1; bt < (bitsize - 1); bt++) { if (decode_tacts[bt] == 2) { - //�0 __ 0� - //�0 11 0� + //Х0 __ 0Х + //Х0 11 0Х if ((decode_tacts[bt - 1] == 0 || decode_tacts[bt - 1] == 3) && (decode_tacts[bt + 1] == 0 || decode_tacts[bt + 1] == 4)) { decode_tacts[bt] = 1; restore_sign ^= 2; } - //�0 __ 1� - //�0 10 1� + //Х0 __ 1Х + //Х0 10 1Х if ((decode_tacts[bt - 1] == 0 || decode_tacts[bt - 1] == 3) && (decode_tacts[bt + 1] == 1 || decode_tacts[bt + 1] == 3)){ decode_tacts[bt] = 3; restore_sign ^= 2; } - //�1 __ 0� - //�1 01 0� + //Х1 __ 0Х + //Х1 01 0Х if ((decode_tacts[bt - 1] == 1 || decode_tacts[bt - 1] == 4) && (decode_tacts[bt + 1] == 0 || decode_tacts[bt + 1] == 4)){ decode_tacts[bt] = 4; restore_sign ^= 2; } - //�1 __ 1� - //�1 00 1� + //Х1 __ 1Х + //Х1 00 1Х if ((decode_tacts[bt - 1] == 1 || decode_tacts[bt - 1] == 4) && (decode_tacts[bt + 1] == 1 || decode_tacts[bt + 1] == 3)){ decode_tacts[bt] = 0; restore_sign ^= 2; @@ -749,22 +745,22 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ } } - //�������������� ���������� ���������� - cdp = cdptr; + //восстановление потерянных полутактов + cdp = cdptr; for(int bt = 1 ; bt < (bitsize - 1); bt++) { if (decode_tacts[bt] == 2) { - //�0 _0 - //�0 10 + //Х0 _0 + //Х0 10 if ((*cdp & 0x0f) < 0x05 && (decode_tacts[bt - 1] == 0 || decode_tacts[bt - 1] == 3)){ - decode_tacts[bt] = 3; + decode_tacts[bt] = 3; restore_sign ^= 1; } - //�1 _1 - //�1 01 + //Х1 _1 + //Х1 01 if ((*cdp & 0x0f) > 0x04 && (decode_tacts[bt - 1] == 1 || decode_tacts[bt - 1] == 4)){ - decode_tacts[bt] = 4; + decode_tacts[bt] = 4; restore_sign ^= 1; } //0_ 0X @@ -773,7 +769,7 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ decode_tacts[bt] = 4; restore_sign ^= 1; } - //1_ 1X + //1_ 1X //10 1X if ((*cdp & 0xF0) > 0x40 && (decode_tacts[bt + 1] == 1 || decode_tacts[bt + 1] == 3)){ decode_tacts[bt] = 3; @@ -783,22 +779,22 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ *cdp++; } - //����� ��������� ��������� �� �������� ������������������, � �� ��� �� ��� ����������� - ���������� :) + //Снова проверяем допустима ли тактовая последовательность, а то что мы там воссановили - неизвестно :) for(int bt = 1; bt < bitsize; bt++) { { - //�0 0X - ����������� + //Х0 0X - недопустима if ((decode_tacts[bt - 1] == 0 || decode_tacts[bt - 1] == 3) && (decode_tacts[bt] == 0 || decode_tacts[bt] == 4)) decode_tacts[bt] = 2; - //�1 1X - ����������� + //Х1 1X - недопустима if ((decode_tacts[bt - 1] == 1 || decode_tacts[bt - 1] == 4) && (decode_tacts[bt] == 1 || decode_tacts[bt] == 3)) decode_tacts[bt] = 2; } *cdp++; } -//����������� ������ ������ �� ��������� -//���� ��������� ���������� �� ��������� ������ ��������, �� ����� ������ � ������ ������ +//Определение версии пакета по преамбуле +//Если преамбула распознана на несколько тактов уверенно, то можно судить о версии пакета //001100110011 -> v2 if (/*decode_tacts[0] == 0 && decode_tacts[1] == 1 &&*/ decode_tacts[2] == 0 && decode_tacts[3] == 1 && decode_tacts[4] == 0 && decode_tacts[5] == 1 && ver == 3){ @@ -821,7 +817,7 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ restore_sign ^=4; } -// ������ ����������� +// Печать расшифорвки if (receiver_dump) { byte* cdp = cdptr; @@ -843,16 +839,16 @@ void Oregon_NR::get_tacts(byte* cdptr, byte bitsize){ return; } //////////////////////////////////////////////////////////////////////////////////////////////////// -//��������� �� �������� ������������������ ������� -//���������: cdptr - ��������� �� ���������� ������ -// btt - �������� � ������. �������� �� ���� ��� ������� ����� ������� ������������ �����, � �������� ��������� ������ -// ������� ���������� �������� ��� "��������" ����������� - ���������� �������� ������� ������. -// ��������� �������� � btt=0 � btt=1 �������� ������ +//Извлекает из тактовой последовательности битовую +//Параметры: cdptr - указатель на записанные данные +// btt - смещение в тактах. Смещение на такт при анализе может поммочь восстановить пакет, у которого разрушено начало +// Функция вовзращает качество или "годность" расшифровки - количесвто уверенно узнаных тактов. +// Сравнивая годность с btt=0 и btt=1 выбираем лучшую //////////////////////////////////////////////////////////////////////////////////////////////////// -int Oregon_NR::get_data(int btt, byte p_ver, byte* cdptr){ //btt - �������� �� ���� ��� ������� ����� ������� ������������ �����, � �������� ��������� ������ +int Oregon_NR::get_data(int btt, byte p_ver, byte* cdptr){ //btt - смещение на такт при анализе может поммочь восстановить пакет, у которого разрушено начало byte* cdp = cdptr; -//������ ������ + //Чистим массив for(int bt=0 ; bt(129)) packet_validity += *cdp - 128; if (*cdp<(127)) packet_validity += 128 - *cdp; cdp++; } - return packet_validity; //���������� ���-�� ����������� ������ + return packet_validity; //возвращаем кол-во достоверных байтов } if (p_ver == 3){ for(int bt = 1 ; bt < READ_BITS; bt++){ - if (*(cdp - 1) > 128) // ���� �� ����� ���� 1 + if (*(cdp - 1) > 128) // если до этого была 1 { - if (decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 1) *cdp -= 2; // ���� 00 ��� 11 - �� ����� 0 - if (decode_tacts[bt - btt] == 3 || decode_tacts[bt - btt] == 4) *cdp += 2; // ���� 01 ��� 10 - �� ����� 1 + if (decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 1) *cdp -= 2; // Если 00 или 11 - то здесь 0 + if (decode_tacts[bt - btt] == 3 || decode_tacts[bt - btt] == 4) *cdp += 2; // Если 01 или 10 - то здесь 1 } - if (*(cdp - 1) < 128) // ���� �� ����� ���� 0 + if (*(cdp - 1) < 128) // если до этого была 0 { - if (decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 1) *cdp += 2; // ���� 00 ��� 11 - �� ����� 1 - if (decode_tacts[bt - btt] == 3 || decode_tacts[bt - btt] == 4) *cdp -= 2; // ���� 01 ��� 10 - �� ����� 0 + if (decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 1) *cdp += 2; // Если 00 или 11 - то здесь 1 + if (decode_tacts[bt - btt] == 3 || decode_tacts[bt - btt] == 4) *cdp -= 2; // Если 01 или 10 - то здесь 0 } - // ���� �� ����� ��������� ���, �� ������ ����� �� ������� ������������ ����� ��� �����. ������� �� ��������� ��� ����� + // если до этого непонятно что, то скорее всего не удалось восстановить целых два такта. смотрим на несколько бит назад - //�������������� ���������� ��� �������� ��� ����� � ���� - if (*(cdp - 1) == 128 && *(cdp - 2) == 128) + //Восстановление очерёдности при пропуске дух битов к ряду + if (*(cdp - 1) == 128 && *(cdp - 2) == 128) { - //0 __ __ 0 - �� �������� + //0 __ __ 0 - не меняется if ((decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 3) && (decode_tacts[bt - btt - 2] == 0 || decode_tacts[bt - btt - 2] == 4)) { if (*(cdp - 2) > 128) *cdp += 1; @@ -915,16 +911,16 @@ int Oregon_NR::get_data(int btt, byte p_ver, byte* cdptr){ //btt - ���� } else { - //1 __ __ 0 ��� 0 __ __ 1- �������� + //1 __ __ 0 или 0 __ __ 1- меняется if (*(cdp - 2) > 128) *cdp -= 1; if (*(cdp - 2) < 128) *cdp += 1; } } - //�������������� ���������� ��� �������� ��� ����� � ���� - if (*(cdp - 1) == 128 && *(cdp - 2) == 128 && *(cdp - 3) == 128) + //Восстановление очерёдности при пропуске трёх битов к ряду + if (*(cdp - 1) == 128 && *(cdp - 2) == 128 && *(cdp - 3) == 128) { - //0 __ __ 0 - �� �������� + //0 __ __ 0 - не меняется if ((decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 3) && (decode_tacts[bt - btt - 3] == 0 || decode_tacts[bt - btt - 3] == 4)) { if (*(cdp - 2) > 128) *cdp += 1; @@ -932,16 +928,16 @@ int Oregon_NR::get_data(int btt, byte p_ver, byte* cdptr){ //btt - ���� } else { - //1 __ __ 0 ��� 0 __ __ 1- �������� + //1 __ __ 0 или 0 __ __ 1- меняется if (*(cdp - 2) > 128) *cdp -= 1; if (*(cdp - 2) < 128) *cdp += 1; } } - //�������������� ���������� ��� �������� ������ ����� � ���� - if (*(cdp - 1) == 128 && *(cdp - 2) == 128 && *(cdp - 3) == 128 && *(cdp - 4) == 128) + //Восстановление очерёдности при пропуске четырёх битов к ряду + if (*(cdp - 1) == 128 && *(cdp - 2) == 128 && *(cdp - 3) == 128 && *(cdp - 4) == 128) { - //0 __ __ 0 - �� �������� + //0 __ __ 0 - не меняется if ((decode_tacts[bt - btt] == 0 || decode_tacts[bt - btt] == 3) && (decode_tacts[bt - btt - 4] == 0 || decode_tacts[bt - btt - 4] == 4)) { if (*(cdp - 2) > 128) *cdp += 1; @@ -949,31 +945,30 @@ int Oregon_NR::get_data(int btt, byte p_ver, byte* cdptr){ //btt - ���� } else { - //1 __ __ 0 ��� 0 __ __ 1- �������� + //1 __ __ 0 или 0 __ __ 1- меняется if (*(cdp - 2) > 128) *cdp -= 1; if (*(cdp - 2) < 128) *cdp += 1; } } - //������ ����� � ������� ����������� ����� �� ����� �� ������������. - + //Больше нибла с помощью контрольной суммы всё равно не восстановить. - //������������ ���-�� ����������� ��� � ������ + //Подсчитываем кол-во достоверных бит в пакете if (*cdp>(129)) packet_validity += *cdp - 128; if (*cdp<(127)) packet_validity += 128 - *cdp; cdp++; } - return packet_validity; //���������� ���-�� ����������� ������ + return packet_validity; //возвращаем кол-во достоверных байтов } } //////////////////////////////////////////////////////////////////////////////////////////////////// -//������������� ������ � �������� ������������� 16384�� -//�.�. ������ ��� � 61��� -//������� ���� ������������� ����. ���� ������� �� ��� ���������. � ������ ��������� ���������� 8 ���������. -//��� ������� ������� ��� ��������� ����������� 1 � ���������������� �����. ���������� ������� - 0x00. ������� ������� � ����� 0�88. -//cdptr - ��������� �� ������� ������, ���� ������������ ������ -//dtl - ��������� �� ���������� ��������� ������ +//Прослушивание канала с частотой дискретизации 16384Гц +//т.е. запись раз в 61мкс +//Каждому такт соответствует байт. Такт делится на два полутакта. В каждом полутакте проводится 8 измерений. +//При наличии сигнала при измерении добавляется 1 к соответствующему ниблу. Отсутствие сигнала - 0x00. Наличие сигнала в такте 0х88. +//cdptr - указатель на область памяти, куда записываются сигнал +//dtl - указатель на количество считанных тактов //////////////////////////////////////////////////////////////////////////////////////////////////// int Oregon_NR::collect(byte* cdptr){ @@ -982,64 +977,64 @@ int Oregon_NR::collect(byte* cdptr){ byte nulls_found = 0; byte bt2 = 0; ////////////////////////////////////////////////////// - //������ �������� � ����� ������� (����� ���������� �������� ������� + 1/16 �����) - if (ver == 2) + //Запись начинаем с этого момента (конец последнего импулься зацепки + 1/16 такта) + if (ver == 2) { - pre_marker += 946; //��� ����� - *cdp = 0x87; //������ ��� ����� �������� - 11. �� �� ������� �������! + pre_marker += 946; //два такта + *cdp = 0x87; //Первые два такта известны - 11. Мы же поймали импульс! cdp++; } if (ver == 3) { - pre_marker += 1434; //��� ����� - *cdp = 0x07; //������ ������ ����� �������� - 0101. �� �� ������� �������! + pre_marker += 1434; //три такта + *cdp = 0x07; //Первые четыре такта известны - 0101. Мы же поймали импульс! *(cdp + 1) = 0x07; cdp += 2; } ////////////////////////////////////////////////////// - //�������� ������ ������ � ������ - // ������������ ����� �������� ��� v3 - 104����, THN132 - 76 ��� + ��� ������� 3 ���� 111, ������� �� ��� ����� + //Начинаем читать данные в память + // Максимальная длина поасылка для v3 - 104БИТА, THN132 - 76 бИТ + как минимум 3 бита 111, которые мы уже нашли byte bt; for (bt = 0 ; bt < READ_BITS2; bt++) { *cdp = 0; - for (byte ckl = 0; ckl < 8; ckl++) { // ������ 8 ��� �� �������� + for (byte ckl = 0; ckl < 8; ckl++) { // Читаем 8 раз за полутакт pre_marker += 61; while (micros() < pre_marker); - if (digitalRead(RECEIVER_PIN)) *cdp += 0x10; // ��������� ��������� � ������� �������� + if (digitalRead(RECEIVER_PIN)) *cdp += 0x10; // Измерения запиываем в старший полубайт } for (byte ckl = 0; ckl < 8; ckl++) { pre_marker += 61; while (micros() < pre_marker); - if (digitalRead(RECEIVER_PIN)) *cdp += 1; // � ��������� �������� ��������� ��������� � ������� ��������. ��� �������� ������. + if (digitalRead(RECEIVER_PIN)) *cdp += 1; // В следующий полутакт измерения запиываем в младший полубайт. Это экономит память. } bt2++; - // ��������� ������ 976.5625 - // ������ 7 ������ ��������� 4��� ��� ������������ ������� � 976��� �� 976.5714��� + 0.009% - if (bt2 == 7) + // Идеальный период 976.5625 + // Каждые 7 тактов добавлять 4мкс для выравнивания периода с 976мкс до 976.5714мкс + 0.009% + if (bt2 == 7) { pre_marker += (4 + timing_correction) ; bt2 = 0; } ///////////////////////////////////////////// - //���� ����� �� ������� ���������� ��������� - //����� ���������, � �� ����������� �� ������� - //���� � ������ ��������� ����� ������� ��� ������ ������, �� ��� ��������� �����������, ��� ��������� ��������� ������ + //Есть время до прихода следующего полутакта + //Можно проверить, а не закончилась ли посылка + //Если в канале последнее время пустота или слабые помехи, то это добавляет уверенности, что наблюдаем окончание пакета yield(); if ((*cdp & 0xf0) < 0x30 && (*cdp & 0x0f) < 0x05) nulls_found++; else nulls_found = 0; cdp++; ///////////////////////////////////////////// - //���� ����� empty_space ������ ����� � ������, �� - //��� ��������� ����� ����� �������. ������ ������ ��� ������ - //empty_space - ����� ������������, ������� �� ���� �������� � ������ ������� - //���� ���������, �������� ������� � ������������ ������ - //���� ���������, �� ����� �� ���������� ������ � ������ ���������� ������ + //Если более empty_space пустых полей в записи, то + //это вероятнее всего конец посылки. Дальше читать нет смысла + //empty_space - число эмпирическое, зависит от типа приёмника и уровня сигнала + //Если уменьшить, возможно спутать с повреждением пакета + //Если увеличить, то можно не прекратить чтение и начать записывать помехи if (nulls_found > empty_space ) return bt; @@ -1052,17 +1047,17 @@ int Oregon_NR::collect(byte* cdptr){ ///////////////////////////////////////////// - //��� ������� ������� ���������� ��������� + //Ждём прихода времени следующего полутакта - while (micros() < pre_marker); + while (micros() < pre_marker); } return bt; } //////////////////////////////////////////////////////////////////////////////////////////////////// -//����������� �������� ������� ���� ������������ ����� -//� �������� ���������� ���������� ��������� �� ������� ������ -// �������������� �������� -// >0 - ������ ����� ������� ������, <0 - ������ ����� ������� ������ +//Определение смещения пакетов друг относительно друга +//В качестве параметров передаются указатели на массивы данных +// Возваращаяется смещение +// >0 - второй пакет начался раньше, <0 - Первый пакет начался раньше //////////////////////////////////////////////////////////////////////////////////////////////////// int Oregon_NR::correlate_data(byte* ser1, byte* ser2){ @@ -1074,7 +1069,7 @@ int Oregon_NR::correlate_data(byte* ser1, byte* ser2){ byte* s1; byte* s2; byte* s2t = ser2; - //������� ������ ����� ������������ ������� + //смещаем первый пакет относительно второго for (byte sht = 0; sht < READ_BITS; sht++){ s1 = ser1; s2 = s2t; @@ -1095,8 +1090,8 @@ int Oregon_NR::correlate_data(byte* ser1, byte* ser2){ } } -//������ �������� -����� ����� ������������ ������� - + //Теперь наоборот -втрой пакет относительно первого + byte* s1t = ser1; for (byte sht = 0; sht < READ_BITS; sht++){ s2 = ser2; @@ -1111,8 +1106,8 @@ int Oregon_NR::correlate_data(byte* ser1, byte* ser2){ yield(); s1t++; } -// ���� ��������� ���������� ��� ����� ��������� - + // Ищем наилучшее совпадение для обоих вариантов + for (int i = 0; i < READ_BITS; i++){ if (shift_score[i] > best_correl_back){ @@ -1120,15 +1115,15 @@ int Oregon_NR::correlate_data(byte* ser1, byte* ser2){ best_shift_back = i; } } - //� ���������� ����� ������ �� ���� + //И возвращаем самое лучшее из двух if (best_correl_back > best_correl) return -best_shift_back; else return best_shift; } //////////////////////////////////////////////////////////////////////////////////////////////////// -//������ �� ���� ������� -//� �������� ���������� ���������� ��������� �� ������� ������ -// ������ ������ ������ ���� �������������� �����, �.�. ��� ������� ����� ����� ������� ���������. -//shift - �������� ������ ������ �������������� ������� +//Сборка из двух пакетов +//В качестве параметров передаются указатели на массивы данных +// Причём первым должен идти результирующий пакет, т.е. тот который имеет более длинную преамбулу. +//shift - смещение втрого пакета относительного первого //////////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_NR::assemble_data(byte* s1, byte* s2, int shift){ @@ -1154,10 +1149,10 @@ void Oregon_NR::assemble_data(byte* s1, byte* s2, int shift){ } } //////////////////////////////////////////////////////////////////////////////////////////////////// -//���������� ������� ����������� � �������. 0xFF - ��� ����������� -// -//code - ��������� �� �������������� ������� ������������������ -//result - ��������� �� ������� ������� +//Возвращает позицию синхронибла в посылке. 0xFF - нет синхронибла +// +//code - указатель на расшифрованную битовую последовательность +//result - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// int Oregon_NR::get_synchro_pos(byte* code){ @@ -1178,27 +1173,27 @@ int Oregon_NR::get_synchro_pos(byte* code){ cp++; } if (!syn_found) return 0xFF; - //������������������ �����, �� ���� ���������, ��� ����� ���� ��� ���������, �. �. ��������� ������� - // � ��������� �� ����� ���� �����! - ��� ������� - //��������� ���� ������������� �� 16-3 = 13 ����� �����. �� ���� �� �� 10!!! - + //Последовательность нашли, но надо убедиться, что перед этим идёт перамбула, т. е. уверенные единицы + // В преамбуле не может быть нулей! - это главное + //Преамбулу надо просматривать на 16-3 = 13 битов назад. Ну хотя бы на 10!!! + for (byte g = i; i - g < 10 && g > 0; g --){ cp --; - if (*cp < 127) return 0xFF; // ����� ������������ � ��������� �� ����� ���� ���������� ����. ��� ��� �����������! + if (*cp < 127) return 0xFF; // Перед синхрониблом в преамбуле не может быть уверенного нуля. Нет тут синхронибла! } return (byte) i; } //////////////////////////////////////////////////////////////////////////////////////////////////// -//������ ������� ������� -//code - ��������� �� �������������� ������� ������������������ -//result - ��������� �� ������� ������� -//valid - ��������� �� ����� ������������� ������� ������� +//Создаёт кодовую посылку +//code - указатель на расшифрованную битовую последовательность +//result - указатель на кодовую посылку +//valid - указатель на карту достоверности кодовой посылки //////////////////////////////////////////////////////////////////////////////////////////////////// int Oregon_NR::get_info_data(byte* code, byte* result, byte* valid){ byte* rd = result; byte* vd = valid; - //������ ������� + //Чистим массивы for (int l = 0; l < PACKET_LENGTH; l++){ *vd = 0; *rd = 0; @@ -1210,20 +1205,20 @@ int Oregon_NR::get_info_data(byte* code, byte* result, byte* valid){ int csm; for (csm = 0; csm < 30; csm++){ - if ( !consist_synchro && (*code < 128 && *(code + 1) > 128 && *(code + 2) < 128 && *(code + 3) > 128)) break; //������� ������������������ 0101 + if ( !consist_synchro && (*code < 128 && *(code + 1) > 128 && *(code + 2) < 128 && *(code + 3) > 128)) break; //Найдена последовательность 0101 if ( consist_synchro && (*code < 127 && *(code + 1) > 129 && *(code + 2) < 127 && *(code + 3) > 129)) break; code++; } - // ���������� � ������ 20 ����� �� ������, ����� ����� �� ����������� �� ������ ������ ���������! - if (ver == 2 & csm > 22) return 0; - // ��� ������� ������ ��������� ����� ���� - if (ver == 3 & csm > 30) return 0; - //��������� �� ������ ���������� + // Синхронибл в первых 20 битах не найден, такой пакет не расшифруешь во второй версии протокола! + if (ver == 2 & csm > 22) return 0; + // ДЛя третьей версии протокола цифра иная + if (ver == 3 & csm > 30) return 0; + //Переходим на начало считывания code += 4; int ii = 0; for (int i = 0; i < READ_BITS - csm; i++) { - // ����� �� ����� �� ������� + // Чтобы не выйти за пределы if (i >= PACKET_LENGTH * 4) break; byte multipl; switch (ii){ @@ -1250,18 +1245,18 @@ int Oregon_NR::get_info_data(byte* code, byte* result, byte* valid){ } // //////////////////////////////////////////////////////////////////////////////////////////////////// -//������� ����������� ������ � �������� +//Функции расшифровки данных с датчиков //////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////// -//���������� �������� ����������� -//oregon_data - ��������� �� ������� ������� +//Возвращает значение температуры +//oregon_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// float Oregon_NR::get_temperature(byte* oregon_data){ if (((sens_type & 0x0FFF) == RTGN318 || sens_type == THGR810 || sens_type == THGN132 || sens_type == THN132) && crc_c) { float tmprt; oregon_data += 8; - //���������� ��������� ������: + //исправляем возможные ошибки: for (int g=0;g < 4; g++) if (*(oregon_data + g) > 9) *(oregon_data + g) = *(oregon_data + g) - 8; tmprt += *(oregon_data) * 0.1; tmprt += *(oregon_data + 1); @@ -1271,22 +1266,22 @@ float Oregon_NR::get_temperature(byte* oregon_data){ // else return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////// -//���������� ��� �������. -//oregon_data - ��������� �� ������� ������� +//Возвращает тип сенсора. +//oregon_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// word Oregon_NR::get_sensor(byte* oregon_data){ return (word)(*(oregon_data))*0x1000 + (*(oregon_data+1))*0x0100 + (*(oregon_data+2))*0x10 + *(oregon_data+3); } //////////////////////////////////////////////////////////////////////////////////////////////////// -//���������� �������� ������ -//oregon_data - ��������� �� ������� ������� +//Возвращает значение канала +//oregon_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_channel(byte* oregon_data){ if (crc_c) { byte channel = 0; -// word sens_type = get_sensor(oregon_data); + // word sens_type = get_sensor(oregon_data); if (sens_type == THGN132 || sens_type == THN132 ) { switch (*(oregon_data + 4)) @@ -1316,15 +1311,15 @@ byte Oregon_NR::get_battery(byte* oregon_data){ else return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////// -//���������� �������� ��������� -//oregon_data - ��������� �� ������� ������� +//Возвращает значение влажности +//oregon_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// float Oregon_NR::get_humidity(byte* oregon_data){ if (((sens_type & 0x0FFF) == RTGN318 || sens_type == THGR810 || sens_type == THGN132) && crc_c ){ byte tmprt = 0; oregon_data += 12; - //���������� ��������� ������: + //исправляем возможные ошибки: for (int g=0; g < 2; g++) if (*(oregon_data + g) > 9) *(oregon_data + g) = *(oregon_data + g) - 8; tmprt = *(oregon_data); tmprt += *(oregon_data + 1) * 10; @@ -1333,8 +1328,8 @@ float Oregon_NR::get_humidity(byte* oregon_data){ else return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////// -//���������� id ������� -//oregon_data - ��������� �� ������� ������� +//Возвращает id датчика +//oregon_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_id(byte* oregon_data){ if (((sens_type & 0x0FFF) == RTGN318 || sens_type == THGR810 || sens_type == THGN132 || sens_type == THN132 || sens_type == WGR800 || sens_type == UVN800) && crc_c) @@ -1349,8 +1344,8 @@ byte Oregon_NR::get_id(byte* oregon_data){ } //////////////////////////////////////////////////////////////////////////////////////////////////// -//���������� ������� �������� ����� � �/c -//oregon_data - ��������� �� ������� ������� +//Возвращает среднее значение ветра в м/c +//oregon_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// float Oregon_NR::get_avg_windspeed(byte* oregon_data) { @@ -1364,8 +1359,8 @@ float Oregon_NR::get_avg_windspeed(byte* oregon_data) } //////////////////////////////////////////////////////////////////////////////////////////////////// -//���������� ������� ������������� ������ ����� � �/c -//oregon_data - ��������� �� ������� ������� +//Возвращает начение максимального порыва ветра в м/c +//oregon_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// float Oregon_NR::get_max_windspeed(byte* oregon_data) { @@ -1379,22 +1374,22 @@ float Oregon_NR::get_max_windspeed(byte* oregon_data) } //////////////////////////////////////////////////////////////////////////////////////////////////// -//���������� ����������� ����� � ���������� -//oregon_data - ��������� �� ������� ������� +//Возвращает направление ветра в квадрантах +//oregon_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_winddirection(byte* oregon_data) { if (sens_type == WGR800 && crc_c){ byte tmprt; return *(oregon_data + 8) & 0x0F; - //��������� 0-N, 1-NNE, 2-NE, 3-ENE, 4-E, 5-ESE, 6-SE, 7-SSE, 8-S, 9-SSW, A-SW, B-WSW, C-W, D-WNW, E-NW,F-NNW + //Квадранты 0-N, 1-NNE, 2-NE, 3-ENE, 4-E, 5-ESE, 6-SE, 7-SSE, 8-S, 9-SSW, A-SW, B-WSW, C-W, D-WNW, E-NW,F-NNW } else return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////// -//���������� UV-������ -//oregon_data - ��������� �� ������� ������� +//Возвращает UV-индекс +//oregon_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_UV(byte* oregon_data) { @@ -1408,8 +1403,8 @@ byte Oregon_NR::get_UV(byte* oregon_data) } //////////////////////////////////////////////////////////////////////////////////////////////////// -//���������� ������������ � �������� �������� -//oregon_data - ��������� �� ������� ������� +//Возвращает освещённость в условных единицах +//oregon_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_light(byte* oregon_data) { @@ -1454,8 +1449,8 @@ float Oregon_NR::get_rain_rate(byte* oregon_data) else return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////// -//�������� CRC -//oregon_data - ��������� �� ������� ������� +//Проверка CRC +//oregon_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// bool Oregon_NR::check_CRC(byte* oregon_data, word sens_type){ @@ -1636,7 +1631,7 @@ bool Oregon_NR::check_CRC(byte* oregon_data, word sens_type){ return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////// -//������������� ������ �� ���� ������� +//Востановление данных по типу датчика //////////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_NR::restore_data(byte* oregon_data, word sens_type){ @@ -1674,8 +1669,8 @@ void Oregon_NR::led_light(bool led_on) { // #if ADD_SENS_SUPPORT == 1 //////////////////////////////////////////////////////////////////////////////////////////////////// -//������� ����������� ������ �������� GAS -//gas_data - ��������� �� ������� ������� +//Функции расшифровки данных датчиков GAS +//gas_data - указатель на кодовую посылку //////////////////////////////////////////////////////////////////////////////////////////////////// byte Oregon_NR::get_gas_channel(byte* gas_data){ diff --git a/Oregon_NR.h b/Oregon_NR.h index e1d5990..358e774 100644 --- a/Oregon_NR.h +++ b/Oregon_NR.h @@ -42,138 +42,135 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// ������ ���������� ������� ������������� ��� ������ � �������� ������ � ������� ������������� ��������� Oregon Scientific v2.1 � v3.0 +// Данная библиотека Ардуино предназначена для приема и передачи данных в формате беспроводного протокола Oregon Scientific v2.1 и v3.0 // -// ��������� ���������� 14 ������� 2019 +// Последнее обновление 29 июня 2019 // -// �������������� ������ ��������� �������� +// Поддерживается формат следующих датчиков // -// ���� � ��������: +// Приём и передача: // THGN132N (THGR122N, THGN123N), // RTGN318, // THGR810. -// ������ ����: +// Тольок приём: // THN132N, // WGR800, // UVN800, // PCR800. // -// ����� �������������� ������� ����������� ���������� (�� �������������� ������������ ���������� � ������) +// Также поддерживаются датчики собственной разработки (за дополнительной документацей обращаться к автору) // -// ���� ���� - ����� ���������� OREGON_NR +// Этот файл - часть библиотеки OREGON_NR ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Copyright (c) 2019 ������ �������� +// Copyright (c) 2019 Сергей Зависляк // -// ������ �������� ��������� �����, ���������� ����� ������� ������������ ����������� � ������������� ������������ -// (� ���������� ���������� ������������ �����������), ������������ ������������ ����������� ����������� ��� �����������, -// ������� �������������� ����� �� �������������, �����������, ���������, �������, ����������, ���������������, ����������������� -// �/��� ������� ����� ������������ �����������, � ����� �����, ������� ��������������� ������ ����������� �����������, ��� ���������� ��������� �������: +// Данная лицензия разрешает лицам, получившим копию данного программного обеспечения и сопутствующей документации +// (в дальнейшем именуемыми «Программное Обеспечение»), безвозмездно использовать Программное Обеспечение без ограничений, +// включая неограниченное право на использование, копирование, изменение, слияние, публикацию, распространение, сублицензирование +// и/или продажу копий Программного Обеспечения, а также лицам, которым предоставляется данное Программное Обеспечение, при соблюдении следующих условий: // -// ��������� ���� ����������� �� ��������� ����� � ������ ������� ������ ���� �������� �� ��� ����� ��� �������� ����� ������� ������������ �����������. +// Указанное выше уведомление об авторском праве и данные условия должны быть включены во все копии или значимые части данного Программного Обеспечения. // -// ������ ����������� ����������� ��������������� ���� ���ܻ, ��� �����-���� ��������, ���� ���������� ��� ���������������, ������� �������� �������� -// �����������, ������������ �� ��� ����������� ���������� � ���������� ���������, �� �� ������������� ���. �� � ����� ������ ������ ��� ��������������� -// �� ����� ��������������� �� �����-���� �����, �� ����� ��� �� ���� �����������, � ��� �����, ��� �������� ���������, ������� ��� ���� ��������, -// ��������� ��-�� ������������� ������������ ����������� ��� ���� �������� � ����������� ������������. +// ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ +// ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ +// НЕ НЕСУТ ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА УЩЕРБ ИЛИ ПО ИНЫМ ТРЕБОВАНИЯМ, В ТОМ ЧИСЛЕ, ПРИ ДЕЙСТВИИ КОНТРАКТА, ДЕЛИКТЕ ИЛИ ИНОЙ СИТУАЦИИ, +// ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// -// ������������� ������� �� ��������� �������� Oregon Scientific: +/// Распознавание пакетов от следующих датчиков Oregon Scientific: // -#define THGN132 0x1D20 // �����������, ���������, 3 ������, -#define THN132 0xEC40 // �����������, 3 ������, -#define RTGN318 0xDCC3 // �����������, ���������, 5 �������, -#define THGR810 0xF824 // �����������, ���������, 10 �������, -#define WGR800 0x1984 // ����������� � �������� ����� -#define UVN800 0xD874 // ��-������, ������������ (������� XOR �� ��������������� ������) +#define THGN132 0x1D20 // Температура, влажность, 3 канала, +#define THN132 0xEC40 // Температура, 3 канала, +#define RTGN318 0xDCC3 // Температура, влажность, 5 каналов, +#define THGR810 0xF824 // Температура, влажность, 10 каналов, +#define WGR800 0x1984 // Направление и скорость ветра +#define UVN800 0xD874 // УФ-индекс, освещённость (спасибо XOR за предоставленные данные) #define PCR800 0x2914 // Rain gauge // -// ������� ����������� ����������: -#define THP 0x5500 // �����������, ���������, ��� ��������, 8 �������, ������ �� 3-�� ������� ��, -#define GAS 0xAA00 // �����������, ���������, ������������ �� � CH4, 8 �������, -#define FIRE 0xBB00 // �������� �������� �������� ����� �������� ��22 � ��72 -#define CURRENT 0xEE00 // ���, ����������, 8 �������, -#define CAPRAIN 0x8800 // ��������� ����������� ������ ������� +// Датчики собственной разработки: +#define THP 0x5500 // Температура, влажность, атм давление, 8 каналов, работа от 3-ех батарей АА, +#define GAS 0xAA00 // Температура, влажность, концентрация СО и CH4, 8 каналов, +#define FIRE 0xBB00 // Контроль сигналов пожарных линий датчиков ИП22 и ИП72 +#define CURRENT 0xEE00 // Ток, напряжение, 8 каналов, +#define CAPRAIN 0x8800 // Емкостной всепогодный датчик осадков // -//����� ����������� ����� �������� ��� �������� �������� -#define ADD_SENS_SUPPORT 1 // �������� �������������� ����� �������� ����������� ���������� - ���������� ������������� �������� ��� -#define IS_ASSEMBLE 1 // �������� �� ������� �� ���� ����������� ������� ���� ����� (��� v2) - ���������� ������ �������� ���! +//Этими параметрами можно поиграть для экономии ресурсов +#define ADD_SENS_SUPPORT 1 // ПОддежка дополнительных типов датчиков собственной разработки - отключение незначительно экономит ресурсы +#define IS_ASSEMBLE 1 // Пытаться ли собрать из двух повреждённых пакетов один целый (для v2) - сильно экономит ОЗУ! // -// ����� ����������� ����� �������� ��� ��������� ���������� ����� +// Этими параметрами можно поиграть для настройки наилучшего приёма + +#define MAX_LENGTH2 976 // Максимальная длина импульса преамбулы v2 - не меньше периода, чтобы ловился сигнал от разных эмуляторов +#define MIN_LENGTH2 883 // Минимальная длина импульса при захвате (для v2 импульсы укорочены на 93мкс), т.е. должна быть не больше 883мкс, -#define MAX_LENGTH2 976 // ������������ ����� �������� ��������� v2 - �� ������ �������, ����� ������� ������ �� ������ ���������� -#define MIN_LENGTH2 883 // ����������� ����� �������� ��� ������� (��� v2 �������� ��������� �� 93���), �.�. ������ ���� �� ������ 883���, - -#define MAX_LENGTH3 488 // ������������ ����� �������� ��������� v3 - �� ������ �����������, ����� ������� ������ �� ������ ���������� -#define MIN_LENGTH3 330 // ����������� ����� �������� ��� ������� (��� v2 �������� ��������� �� 138���), �.�. ������ ���� �� ������ 350���, +#define MAX_LENGTH3 488 // Максимальная длина импульса преамбулы v3 - не меньше полупериода, чтобы ловился сигнал от разных эмуляторов +#define MIN_LENGTH3 330 // Минимальная длина импульса при захвате (для v2 импульсы укорочены на 138мкс), т.е. должна быть не больше 350мкс, -#define LENGTH_TOLERANCE 64 // ���������� ���������� ��� ����� ��������. ������� �� �������� - // � ����������� �� ������ ������� ����� "������� ����� ���������" +#define LENGTH_TOLERANCE 64 // Допустимое отклонение для длины импульса. Зависит от приёмника + // В зависимости от уровня сигнала может "плавать длина импульсов" -#define CATCH_PULSES 3 // ������� ������ ���������� ��������� ��� ������ �������. ������������� 2 - 4. - // ������ - ����� �� ������� ����� � �������� ������� ����� - // ������ - ����� ���������� �����, ������ ���������� �� ������ ����� +#define CATCH_PULSES 3 // Сколько искать правильных импульсов для начала захвата. Рекомендовано 2 - 4. + // Больше - можно не поймать пакет в условиях сильных шумов + // Меньше - можно пропустить пакет, сильно отвлекаясь на анализ шумов -//��� ��������� ������� �� ����! +//Эти параметры трогать не надо! -#define FIND_PACKET 1 +#define FIND_PACKET 1 #define ANALIZE_PACKETS 2 -#define PER_LENGTH2 976 // ������ �������� ������. ��� v2 � v3 976,56��� (1024��) +#define PER_LENGTH2 976 // Период передачи данных. Для v2 и v3 976,56мкс (1024Гц) #define PER_LENGTH3 488 -#define READ_BITS 105 // ������������ ����� ������ � ������ -#define READ_BITS2 210 // ������������ ����� ������ � ������ * 2 -#define PACKET_LENGTH 20 // ����� ������ � ������ ��� ����� ��������� (� ������������) +#define READ_BITS 105 // Максимальная длина пакета в тактах +#define READ_BITS2 210 // Максимальная длина пакета в тактах * 2 +#define PACKET_LENGTH 20 // Длина пакета в ниблах без учёта преамбулы (с синхрониблом) static int RECEIVER_PIN; class Oregon_NR { public: - - //������ ������� - word sens_type; //Sensor type - - - float sens_tmp, //Temperature - sens_hmdty; //Humidity - - byte sens_chnl, //Channel number - sens_id, //ID - sens_battery; //Battery status - - byte ver = 0; //Protocol version - - bool crc_c = 0; //CRC check result. ������������ ��� �������. ������������ ��� ����� ����������� ������. - bool captured = 0; //Capture data flag. ������������, ���� ���� ������� ������ � ������. - - unsigned long work_time; //Capture time - byte packet[PACKET_LENGTH]; //Result packet - byte valid_p[PACKET_LENGTH]; //Validity mask - ����� ���������� ������������� ����� - byte packets_received = 0; //Number of received packets in block (0...2) - byte received_CRC; //Calculated �RC - - Oregon_NR(byte, byte); //�����������. ���������: - Oregon_NR(byte, byte, byte, bool); //(����� ��������, ����� ����������, ����� ����������, pull up) - void start(); //Star listening receiver - void stop(); //Stop listening receiver. ����� �� ������� ���������, ����� �� ����� - void capture(bool); //Capture packet. if parameter is true function dumps capture data to Serial. - - bool consist_synchro = false; //��� ������ ����������� ��������� ������������� ��� ������������ ������? - - byte empty_space = 3; //����� ���������� "������" ������ ����� ��� ����������� ����� �������? - //�������� ������������ ������� ������� � ��������� ��� ��������. - //��� ��� �����, ��� ������ �����. �� ������ ���� �� ������������� - //� ������ ������ ���� 5 - bool catch2 = 1, catch3 = 1; //����� ������ ��������� ��������� - int timing_correction = 0; //��������� ������� ����� (�� -10 �� +10) - byte decode_method = 3; // ����� ������������� ������ - //1 - ������������ - //3 - ��� �������� ������� - - //��������� + //Данные датчика + word sens_type; //Sensor type + + float sens_tmp, //Temperature + sens_hmdty; //Humidity + + byte sens_chnl, //Channel number + sens_id, //ID + sens_battery; //Battery status + + byte ver = 0; //Protocol version + + bool crc_c = 0; //CRC check result. Сбрасывается при захвате. Выставляется при приёме корректного пакета. + bool captured = 0; //Capture data flag. Выставляется, если были считаны данные в память. + + unsigned long work_time; //Capture time + byte packet[PACKET_LENGTH]; //Result packet + byte valid_p[PACKET_LENGTH]; //Validity mask - маска уверенного распознавания битов + byte packets_received = 0; //Number of received packets in block (0...2) + byte received_CRC; //Calculated СRC + + Oregon_NR(byte, byte); //Конструктор. Параметры: + Oregon_NR(byte, byte, byte, bool); //(вывод приёмника, номер прерывания, вывод светодиода, pull up) + void start(); //Star listening receiver + void stop(); //Stop listening receiver. Чтобы не занимал процессор, когда не нужен + void capture(bool); //Capture packet. if parameter is true function dumps capture data to Serial. + + bool consist_synchro = false; //При поиске синхронибла опираться подтверждённые или сомнительные данные? + + byte empty_space = 3; //Какое количество "пустых" тактов нужно для определения конца посылки? + //Параметр определяется уровнем сигнала и скоростью АРУ приёмника. + //Чем они лучше, тем меньше число. НО меньше двух не рекомендуется + //В сатрой версии было 5 + bool catch2 = 1, catch3 = 1; //какие версии протокола принимать + int timing_correction = 0; //Коррекция частоты приёма (от -10 до +10) + byte decode_method = 3; // Метод декодирования тактов + //1 - традиционный + //3 - при девиации частоты + + //Ветрометр float sens_avg_ws, sens_max_ws; byte sens_wdir; float get_avg_windspeed(byte*); @@ -188,71 +185,68 @@ class Oregon_NR float get_total_rain(byte*); float get_rain_rate(byte*); - byte restore_sign; //������� ����, ������������ �� �������� �������� ����������� ������ - - //0 - ������������� ��������� ����� - //1 - ������������� ������� ����� - //2 - ����������� ������ ��������� ��� �������� ������ - //3 - ������������� ������� ���������� (v2) - ��������� ��� �������� �������� - - bool receiver_dump = 0; //���������� �� ���� ������ � Serial. �������� ������ ���� capture(true) - // ���������� ��� ������������� ��������� ������� � �������� - // ����� ��������� �������� ������������������ �� � ����� �������������� - -#if ADD_SENS_SUPPORT == 1 - float sens_pressure, //Pressure - sens_voltage, // ���������� � � (for CURRENT � THP sensors) - sens_tmp2; //Temperature2 (for GASv2 sensor) - byte sens_CO, //CO (ppm*10) (for GASv2 sensor) - sens_CH; //CH4 (ppm*100)(ppm) - byte sens_ip22, //IP22 channel data (for FIRE sensor) - sens_ip72, //IP72 channel data (for FIRE sensor) - sens_lockalarm; //LOCK_ALARM channel data (for FIRE sensor) - float sens_current; // ��� � � (for CURRENT sensor) - - word sens_pump_count; // ������� ������ - unsigned long sens_drop_counter;// ������� ������ (for CAPRAIN sensor) - int sens_capacitance; //������� ������� (for CAPRAIN sensor) -#endif - + byte restore_sign; //Битовое поле, инормирующее об успешных способах реставрации пакета + + //0 - восстановлены одиночные такты + //1 - восстановлены двойные такты + //2 - исправление версии протокола при разборке пакета + //3 - восстановлено методом сращивания (v2) - отключено для экономии ресурсов + + bool receiver_dump = 0; //Сбрасывать ли дамп канала в Serial. работает тольок если capture(true) + // фактически это осциллограмма огибающей сигнала с приёмника + // Также выводятся тактовые последовательности до и после восстановления + + #if ADD_SENS_SUPPORT == 1 + float sens_pressure, //Pressure + sens_voltage, // напряжение в В (for CURRENT и THP sensors) + sens_tmp2; //Temperature2 (for GASv2 sensor) + byte sens_CO, //CO (ppm*10) (for GASv2 sensor) + sens_CH; //CH4 (ppm*100)(ppm) + byte sens_ip22, //IP22 channel data (for FIRE sensor) + sens_ip72, //IP72 channel data (for FIRE sensor) + sens_lockalarm; //LOCK_ALARM channel data (for FIRE sensor) + float sens_current; // ток в А (for CURRENT sensor) + + word sens_pump_count; // счётчик насоса + unsigned long sens_drop_counter; // счётчик капель (for CAPRAIN sensor) + int sens_capacitance; //Емкость сенсора (for CAPRAIN sensor) + #endif private: - - byte read_tacts, read_tacts2, result_size; - byte LED = 0xFF; //����� ����������, ������� ������ ��� ����� - bool PULL_UP; //���� ��������� ��������� - byte packet_number = 0; //���������� �������� ������� � ������� - int INT_NO; //����� ���������� �������� - //bool reciever_ctrl = true; //���� �������� �������� (������������ ��� ������� ��������, ������������ � �������) - - //������� ������ ��� ������ ������ � ������ � ���������� ����� - byte decode_tacts[READ_BITS2]; //������ ������. �������� - // 0=���� - // 1=������� - // 2=���������� - // 3=�������+ - // 4=�������- - - byte collect_data[READ_BITS2], //������ ��� ����� ������ � �������� -#if IS_ASSEMBLE - collect_data2[READ_BITS2]; -#else - collect_data2[1]; -#endif - //� ����� ���������� �������� ���������� �����, �� �������� �����: - // 128 - ���������� - // >128 - ������� - // <128 - ���� + byte LED = 0xFF; //вывод светодиода, который мигает при приёме + bool PULL_UP; //куда подключён светодиод + byte packet_number = 0; //Количесвто принятых пакетов в посылке + int INT_NO; //Номер прерывания приёмника + //bool reciever_ctrl = true; //Флаг контроля ресивера (выставляется при приходе импулься, сбрасывается в таймере) + + //Массивы данных для записи данных с канала и полученных битов + byte decode_tacts[READ_BITS2]; //Массив тактов. значения + // 0=ноль + // 1=единица + // 2=неизвестен + // 3=переход+ + // 4=переход- + + byte collect_data[READ_BITS2], //Память для сбора данных с приёмника + #if IS_ASSEMBLE + collect_data2[READ_BITS2]; + #else + collect_data2[1]; + #endif + //А когда становится массивом полученных битов, то значения такие: + // 128 - неизвестен + // >128 - единица + // <128 - ноль byte receive_status = FIND_PACKET; byte start_pulse_cnt = 0; - unsigned long pulse_length, timer_marklong; + unsigned long pulse_length, timer_marklong; unsigned long pulse_marker, right_pulse_marker; - unsigned long pre_marker; // ��� �������� ��������� ����� ��������� ��� ������� ������ + unsigned long pre_marker; // Для хранения временных меток преамбулы при захвате пакета unsigned long first_packet_end; - byte data_val, data_val2; // �������� ������� - byte synchro_pos, synchro_pos2; // ������� ������������ � ������ + byte data_val, data_val2; // Качество пакетов + byte synchro_pos, synchro_pos2; // Позиции синхрониблов в записи byte get_gas_CH(byte* gas_data); byte get_gas_CO(byte* gas_data); @@ -290,9 +284,8 @@ class Oregon_NR float get_thp_temperature(byte* oregon_data); float get_thp_pressure(byte* oregon_data); float get_thp_voltage(byte* oregon_data); -#endif +#endif }; #endif - diff --git a/Oregon_TM.cpp b/Oregon_TM.cpp index c44cd28..23ba87b 100644 --- a/Oregon_TM.cpp +++ b/Oregon_TM.cpp @@ -1,7 +1,7 @@ #include "Oregon_TM.h" ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// This Arduino code is for receive and transmit data using Oregon Scientific RF protocol version 2.1 and 3.0. +// This Arduino code is for receive and transmit data using Oregon Scientific RF protocol version 2.1 and 3.0. // // Last updated: 14 October 2019 // @@ -17,14 +17,14 @@ // WGR800, // UVN800. // -// Also supported self-developed sensors. Please contact author for additional information. +// Aslo supported self-developed sensors. Please contact author for additional infromation. // // This file is part of the Arduino OREGON_NR library. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // The MIT License (MIT) // -// Copyright (c) 2019 Sergey Zawislak +// Copyright (c) 2019 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, @@ -33,73 +33,72 @@ // 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 +// 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 Scientific v2.1 � v3.0 +// Данная библиотека Ардуино предназначена для приема и передачи данных в формате беспроводного протокола Oregon Scientific v2.1 и v3.0 // -// ��������� ���������� 14 ������� 2019 +// Последнее обновление 14 Октября 2019 // -// �������������� ������ ��������� �������� +// Поддерживается формат следующих датчиков // -// ���� � ��������: +// Приём и передача: // THGN132N (THGR122N, THGN123N), // RTGN318, // THGR810. -// ������ ����: +// Тольок приём: // THN132N, -// WGR800, +// WGR800, // UVN800. // -// ����� �������������� ������� ����������� ���������� (�� �������������� ������������ ���������� � ������) +// Также поддерживаются датчики собственной разработки (за дополнительной документацей обращаться к автору) // -// ���� ���� - ����� ���������� OREGON_NR +// Этот файл - часть библиотеки OREGON_NR ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Copyright (c) 2019 ������ �������� +// Copyright (c) 2019 Сергей Зависляк // -// ������ �������� ��������� �����, ���������� ����� ������� ������������ ����������� � ������������� ������������ -// (� ���������� ���������� ������������ �����������), ������������ ������������ ����������� ����������� ��� �����������, -// ������� �������������� ����� �� �������������, �����������, ���������, �������, ����������, ���������������, ����������������� -// �/��� ������� ����� ������������ �����������, � ����� �����, ������� ��������������� ������ ����������� �����������, ��� ���������� ��������� �������: +// Данная лицензия разрешает лицам, получившим копию данного программного обеспечения и сопутствующей документации +// (в дальнейшем именуемыми «Программное Обеспечение»), безвозмездно использовать Программное Обеспечение без ограничений, +// включая неограниченное право на использование, копирование, изменение, слияние, публикацию, распространение, сублицензирование +// и/или продажу копий Программного Обеспечения, а также лицам, которым предоставляется данное Программное Обеспечение, при соблюдении следующих условий: // -// ��������� ���� ����������� �� ��������� ����� � ������ ������� ������ ���� �������� �� ��� ����� ��� �������� ����� ������� ������������ �����������. +// Указанное выше уведомление об авторском праве и данные условия должны быть включены во все копии или значимые части данного Программного Обеспечения. // -// ������ ����������� ����������� ��������������� ���� ���ܻ, ��� �����-���� ��������, ���� ���������� ��� ���������������, ������� �������� �������� -// �����������, ������������ �� ��� ����������� ���������� � ���������� ���������, �� �� ������������� ���. �� � ����� ������ ������ ��� ��������������� -// �� ����� ��������������� �� �����-���� �����, �� ����� ��� �� ���� �����������, � ��� �����, ��� �������� ���������, ������� ��� ���� ��������, -// ��������� ��-�� ������������� ������������ ����������� ��� ���� �������� � ����������� ������������. +// ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ +// ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ +// НЕ НЕСУТ ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА УЩЕРБ ИЛИ ПО ИНЫМ ТРЕБОВАНИЯМ, В ТОМ ЧИСЛЕ, ПРИ ДЕЙСТВИИ КОНТРАКТА, ДЕЛИКТЕ ИЛИ ИНОЙ СИТУАЦИИ, +// ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//����������� +//Конструктор Oregon_TM::Oregon_TM(byte tr_pin) { TX_PIN = tr_pin; - pinMode(TX_PIN, OUTPUT); + pinMode(TX_PIN, OUTPUT); digitalWrite(TX_PIN, LOW); - } Oregon_TM::Oregon_TM(void) { - pinMode(TX_PIN, OUTPUT); + pinMode(TX_PIN, OUTPUT); digitalWrite(TX_PIN, LOW); } /////////////////////////////////////////////////////////////////////////////////////////////////// -// ������� �����������//////////////////////////////////////////////////////////////////////////// +// Функции передатчика//////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_TM::sendZero(void) { - if (protocol == 2){ + if (protocol == 2) { while (time_marker + TR_TIME * 4 >= micros()); time_marker += TR_TIME * 4; digitalWrite(TX_PIN, HIGH); @@ -108,19 +107,18 @@ void Oregon_TM::sendZero(void) 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()); - + 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; + return; } if (prevbit && !prevstate) { @@ -128,7 +126,7 @@ void Oregon_TM::sendZero(void) delayMicroseconds(TWOTR_TIME); prevstate = 1; prevbit = 0; - return; + return; } if (!prevbit && prevstate) { @@ -136,7 +134,7 @@ void Oregon_TM::sendZero(void) delayMicroseconds(TR_TIME); digitalWrite(TX_PIN, HIGH); prevbit = 0; - return; + return; } if (!prevbit && !prevstate) { @@ -144,7 +142,7 @@ void Oregon_TM::sendZero(void) delayMicroseconds(TR_TIME); digitalWrite(TX_PIN, LOW); prevbit = 0; - return; + return; } } } @@ -152,7 +150,7 @@ void Oregon_TM::sendZero(void) void Oregon_TM::sendOne(void) { - if (protocol == 2){ + if (protocol == 2) { while (time_marker + TR_TIME * 4 - PULSE_SHORTEN_2>= micros()); time_marker += TR_TIME * 4; digitalWrite(TX_PIN, LOW); @@ -161,13 +159,12 @@ void Oregon_TM::sendOne(void) delayMicroseconds(TWOTR_TIME - PULSE_SHORTEN_2); digitalWrite(TX_PIN, LOW); } - - if (protocol == 3) - { + + 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); @@ -180,7 +177,7 @@ void Oregon_TM::sendOne(void) digitalWrite(TX_PIN, HIGH); prevstate = 1; prevbit = 1; - return; + return; } if (prevbit && prevstate) { @@ -188,7 +185,7 @@ void Oregon_TM::sendOne(void) delayMicroseconds(TR_TIME); digitalWrite(TX_PIN, HIGH); prevbit = 1; - return; + return; } if (prevbit && !prevstate) { @@ -196,9 +193,8 @@ void Oregon_TM::sendOne(void) delayMicroseconds(TR_TIME); digitalWrite(TX_PIN, LOW); prevbit = 1; - return; + return; } - } } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -209,20 +205,18 @@ void Oregon_TM::sendMSB(byte data) (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 == 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 == 2) time_marker += timing_corrector2; //Поправка на разницу тактовых частот 1024.07Гц и 1024.60Гц if (protocol == 3) time_marker += timing_corrector3; } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -234,33 +228,33 @@ void Oregon_TM::sendData() sendMSB(SendBuffer[i]); if (i < 9) sendLSB(SendBuffer[i]); - if (protocol == 2) time_marker += 4; //�������� �� ������� �������� ������ 1024.07�� � 1024.60�� - //if (protocol == 3) time_marker += 4; - //�������� �� ������� �������� ������ 1024.07�� � 1024�� + 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(); + time_marker=micros(); + sendPreamble(); + sendLSB(0xA); + sendData(); } /////////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_TM::sendPreamble(void) { - if (protocol == 2){ + if (protocol == 2) { sendLSB(0xF); sendLSB(0xF); - time_marker += 9; + time_marker += 9; sendLSB(0xF); sendLSB(0xF); time_marker += 9; } - if (protocol == 3){ + if (protocol == 3) { sendLSB(0xF); sendLSB(0xF); sendLSB(0xF); @@ -273,7 +267,7 @@ void Oregon_TM::sendPreamble(void) } /////////////////////////////////////////////////////////////////////////////////////////////////// - + void Oregon_TM::calculateAndSetChecksum132(void) { byte CCIT_POLY = 0x07; @@ -283,7 +277,7 @@ void Oregon_TM::calculateAndSetChecksum132(void) byte summ = 0x00; byte crc = 0x3C; byte cur_nible; - for(int i = 0; i<8; i++) + for(int i = 0; i<8; i++) { cur_nible = (SendBuffer[i] & 0xF0) >> 4; summ += cur_nible; @@ -293,7 +287,7 @@ void Oregon_TM::calculateAndSetChecksum132(void) 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) @@ -302,7 +296,7 @@ void Oregon_TM::calculateAndSetChecksum132(void) 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; @@ -320,7 +314,7 @@ void Oregon_TM::calculateAndSetChecksum318() byte summ = 0x00; byte crc = 0x00; byte cur_nible; - for(int i = 0; i<8; i++) + for(int i = 0; i<8; i++) { cur_nible = (SendBuffer[i] & 0xF0) >> 4; summ += cur_nible; @@ -330,7 +324,7 @@ void Oregon_TM::calculateAndSetChecksum318() 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) @@ -339,7 +333,7 @@ void Oregon_TM::calculateAndSetChecksum318() 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; @@ -360,25 +354,24 @@ void Oregon_TM::calculateAndSetChecksum810() for(int j = 0; j < 4; j++) if (crc & 0x80) crc = (crc << 1) ^ CCIT_POLY; else crc <<= 1; - - for(int i = 0; i<8; i++) + + 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; - + + 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; - + + 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; @@ -398,10 +391,10 @@ void Oregon_TM::SendPacket() if (sens_type == THP) calculateAndSetChecksumTHP(); - + sendOregon(); digitalWrite(TX_PIN, LOW); - if (protocol == 2){ + if (protocol == 2) { delayMicroseconds(TWOTR_TIME*15); sendOregon(); digitalWrite(TX_PIN, LOW); @@ -409,298 +402,289 @@ void Oregon_TM::SendPacket() } /////////////////////////////////////////////////////////////////////////////////////////////////// -// ������� ����������� ������////////////////////////////////////////////////////////////////////// +// Функции кодирования данных////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_TM::setType(word type) +{ + sens_type = type; + if (type == THP) { - sens_type = type; - if (type == THP) - { - SendBuffer[0] = 0x55; - return; - } - SendBuffer[0] = (type & 0xFF00) >> 8; - SendBuffer[1] = type & 0x00FF; + 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 == THGN132) { - byte channel_code; - if (sens_type == THGN132) + if (channel <= 1) { - 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; + channel_code = 0x10; + setId(0xE3); + send_time = 39000; } - - if (sens_type == RTGN318) + 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 (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 == RTGN318) + { + 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 (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) { - 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; + channel_code = 0x60; + send_time = 79000; } - SendBuffer[2]&= 0x0F; - SendBuffer[2] += channel_code & 0xF0; + 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; - } +{ + 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; - } +{ + 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; - } +{ + SendBuffer[3] &= 0xF4; + if (startcount == 8) SendBuffer[3] |= 0x08; + if (startcount == 2) SendBuffer[3] |= 0x02; + if (startcount == 1) SendBuffer[3] |= 0x01; +} /////////////////////////////////////////////////////////////////////////////////////////////////// - + void Oregon_TM::setTemperature(float temp) +{ + if(temp < 0) { - 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); + 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) - { - SendBuffer[6] = (hum/10); - SendBuffer[6] += (hum - (SendBuffer[6] * 10)) << 4; - } +{ + SendBuffer[6] = (hum/10); + SendBuffer[6] += (hum - (SendBuffer[6] * 10)) << 4; +} /////////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_TM::setComfort(float temp, byte hum) +{ + if (hum > 70) { - 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; + 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) + if (millis() >= time_marker_send && send_time) { SendPacket(); - time_marker_send = millis() + send_time; + time_marker_send = millis() + send_time; return true; } else return false; } - - - - /////////////////////////////////////////////////////////////////////////////////////////////////// -//��������� ������� THP +//Поддержка датчика 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; - - } -/////////////////////////////////////////////////////////////////////////////////////////////////// +{ + 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; - } -/////////////////////////////////////////////////////////////////////////////////////////////////// +{ + 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; - } +{ + 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; - } +{ + 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; - } +{ + SendBuffer[1] |= 0x0F; + SendBuffer[2] = 0xFF; + SendBuffer[3] = 0xFF; + SendBuffer[4] = 0xFF; + SendBuffer[5] = 0xFF; +} /////////////////////////////////////////////////////////////////////////////////////////////////// void Oregon_TM::calculateAndSetChecksumTHP() { @@ -711,7 +695,7 @@ void Oregon_TM::calculateAndSetChecksumTHP() byte summ = 0x00; byte crc = 0x00; byte cur_nible; - for(int i = 0; i<8; i++) + for(int i = 0; i<8; i++) { cur_nible = (SendBuffer[i] & 0xF0) >> 4; summ += cur_nible; @@ -719,7 +703,7 @@ void Oregon_TM::calculateAndSetChecksumTHP() 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; @@ -732,4 +716,3 @@ void Oregon_TM::calculateAndSetChecksumTHP() SendBuffer[8] += crc & 0x0F; SendBuffer[9] += crc & 0xF0; } - diff --git a/Oregon_TM.h b/Oregon_TM.h index fe7ff9b..2957a1e 100644 --- a/Oregon_TM.h +++ b/Oregon_TM.h @@ -3,7 +3,7 @@ #define Oregon_TM_h ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// This Arduino code is for receive and transmit data using Oregon Scientific RF protocol version 2.1 and 3.0. +// This Arduino code is for receive and transmit data using Oregon Scientific RF protocol version 2.1 and 3.0. // // Last updated: 14 October 2019 // @@ -19,14 +19,14 @@ // WGR800, // UVN800. // -// Also supported self-developed sensors. Please contact author for additional information. +// Aslo supported self-developed sensors. Please contact author for additional infromation. // // This file is part of the Arduino OREGON_NR library. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // The MIT License (MIT) // -// Copyright (c) 2019 Sergey Zawislak +// Copyright (c) 2019 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, @@ -35,58 +35,58 @@ // 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 +// 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 Scientific v2.1 � v3.0 +// Данная библиотека Ардуино предназначена для приема и передачи данных в формате беспроводного протокола Oregon Scientific v2.1 и v3.0 // -// ��������� ���������� 14 ������� 2019 +// Последнее обновление 14 Октября 2019 // -// �������������� ������ ��������� �������� +// Поддерживается формат следующих датчиков // -// ���� � ��������: +// Приём и передача: // THGN132N (THGR122N, THGN123N), // RTGN318, // THGR810. -// ������ ����: +// Тольок приём: // THN132N, -// WGR800, +// WGR800, // UVN800. // -// ����� �������������� ������� ����������� ���������� (�� �������������� ������������ ���������� � ������) +// Также поддерживаются датчики собственной разработки (за дополнительной документацей обращаться к автору) // -// ���� ���� - ����� ���������� OREGON_NR +// Этот файл - часть библиотеки OREGON_NR ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// Copyright (c) 2019 ������ �������� +// Copyright (c) 2019 Сергей Зависляк // -// ������ �������� ��������� �����, ���������� ����� ������� ������������ ����������� � ������������� ������������ -// (� ���������� ���������� ������������ �����������), ������������ ������������ ����������� ����������� ��� �����������, -// ������� �������������� ����� �� �������������, �����������, ���������, �������, ����������, ���������������, ����������������� -// �/��� ������� ����� ������������ �����������, � ����� �����, ������� ��������������� ������ ����������� �����������, ��� ���������� ��������� �������: +// Данная лицензия разрешает лицам, получившим копию данного программного обеспечения и сопутствующей документации +// (в дальнейшем именуемыми «Программное Обеспечение»), безвозмездно использовать Программное Обеспечение без ограничений, +// включая неограниченное право на использование, копирование, изменение, слияние, публикацию, распространение, сублицензирование +// и/или продажу копий Программного Обеспечения, а также лицам, которым предоставляется данное Программное Обеспечение, при соблюдении следующих условий: // -// ��������� ���� ����������� �� ��������� ����� � ������ ������� ������ ���� �������� �� ��� ����� ��� �������� ����� ������� ������������ �����������. +// Указанное выше уведомление об авторском праве и данные условия должны быть включены во все копии или значимые части данного Программного Обеспечения. // -// ������ ����������� ����������� ��������������� ���� ���ܻ, ��� �����-���� ��������, ���� ���������� ��� ���������������, ������� �������� �������� -// �����������, ������������ �� ��� ����������� ���������� � ���������� ���������, �� �� ������������� ���. �� � ����� ������ ������ ��� ��������������� -// �� ����� ��������������� �� �����-���� �����, �� ����� ��� �� ���� �����������, � ��� �����, ��� �������� ���������, ������� ��� ���� ��������, -// ��������� ��-�� ������������� ������������ ����������� ��� ���� �������� � ����������� ������������. +// ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ +// ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ +// НЕ НЕСУТ ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА УЩЕРБ ИЛИ ПО ИНЫМ ТРЕБОВАНИЯМ, В ТОМ ЧИСЛЕ, ПРИ ДЕЙСТВИИ КОНТРАКТА, ДЕЛИКТЕ ИЛИ ИНОЙ СИТУАЦИИ, +// ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #define TR_TIME 488 #define TWOTR_TIME 976 -#define PULSE_SHORTEN_2 80 -#define PULSE_SHORTEN_3 120 +#define PULSE_SHORTEN_2 80 +#define PULSE_SHORTEN_3 120 -#define THGN132 0x1D20 -#define THGR810 0xF824 -#define RTGN318 0xDCC3 -#define THP 0x5500 +#define THGN132 0x1D20 +#define THGR810 0xF824 +#define RTGN318 0xDCC3 +#define THP 0x5500 static byte TX_PIN = 4; static const int buffersize = 10; @@ -97,12 +97,12 @@ class Oregon_TM byte SendBuffer[buffersize]; byte protocol = 2; - word sens_type = 0x0000; + word sens_type = 0x0000; int timing_corrector2 = 4; int timing_corrector3 = 2; - Oregon_TM(byte); - Oregon_TM(); + Oregon_TM(byte); + Oregon_TM(); void setType(word); void setChannel( byte); void setId(byte); @@ -124,7 +124,7 @@ class Oregon_TM private: - + void sendZero(void); void sendOne(void); void sendMSB(const byte); @@ -144,9 +144,6 @@ class Oregon_TM unsigned long send_time = 0; bool prevbit = 1; bool prevstate = 1; - - }; #endif - diff --git a/README.md b/README.md index 946e025..faf6738 100644 --- a/README.md +++ b/README.md @@ -19,40 +19,40 @@ // Also supported self-developed sensors. Please contact author for additional information. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // -// ������ ���������� ������� ������������� ��� ������ � �������� ������ � ������� ������������� ��������� Oregon Scientific v2.1 � v3.0 -// -// ��������� ���������� 14 ������� 2019 -// -// �������������� ������ ��������� �������� -// -// ���� � ��������: -// THGN132N (THGR122N, THGN123N), -// RTGN318, +// Данная библиотека Ардуино предназначена для приема и передачи данных в формате беспроводного протокола Oregon Scientific v2.1 и v3.0 +// +// Последнее обновление 14 Октября 2019 +// +// Поддерживается формат следующих датчиков +// +// Приём и передача: +// THGN132N (THGR122N, THGN123N), +// RTGN318, // THGR810. -// ������ ����: -// THN132N, -// WGR800, -// UVN800. -// -// ����� �������������� ������� ����������� ���������� (�� �������������� ������������ ���������� � ������) -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// -// ��� �������� ������������� �� ������������ �������� THGN132N, THN132N � WGR800. -// -// ��� ����������� ��������������� �� �������� �������� BAR206, BAR208 ��������� ������� THGN132N -// ��� ��������� ����� �������� �������� ������� ���������� ��������� ��������� ������� ��� �������� ������: -// ��������� 2-98% -// ����������� -50...+70� -// ��� �������� ����������������� �������� � ������� "��������� ���" ����� ������, ��� ��������� ����� �������� ��� ��������� ����� �������� �������� -// ������ ���������� �� ����������� �� ����� ��� �� +-1���. �������� ��� THGN132: -// ����� 1 - 39 (38 - 40) c -// ����� 2 - 41 (40 - 42) c -// ����� 3 - 43 (42 - 44) c -// -// ���� ������ ����� � ���������� CRC � ����������� ������, �� �������� ����������� � ��������� ������������, �������� +3.0� �������� �� ��� 0300, � A200 -// �� ������ ����� ���� ������������ �� ����� ID ��� �� ������ �������� ��������. -// ���������� �������� �������� � ��� ������������ ��������� ������ ������ � ID �������. ���� ������ ���� �� ����� �� ������ -// -// �������� �������� � ������� RTGN318 � THGR810 �� ����� �� ��������������. ������� �������� �������� � ������ ���� �������� �������� �������� -// �� ��������� ������� +// Тольок приём: +// THN132N, +// WGR800, +// UVN800. +// +// Также поддерживаются датчики собственной разработки (за дополнительной документацей обращаться к автору) +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Код приёмника протестирован на оригинальных датчиках THGN132N, THN132N и WGR800. +// +// Код передатчика протетстирована на погодных станциях BAR206, BAR208 эмуляцией сигнала THGN132N +// Для успешного приёма погодной станцией сигнала необходимо соблюдать следующие условия при передаче данных: +// Влажность 2-98% +// Температура -50...+70С +// При создании энергосберегающих датчиков с режимом "глубокого сна" нужно учесть, что интервалы между пакетами для успешного приёма погодной станцией +// должны отличаться от номинальных не более чем на +-1сек. Например для THGN132: +// Канал 1 - 39 (38 - 40) c +// Канал 2 - 41 (40 - 42) c +// Канал 3 - 43 (42 - 44) c +// +// Если пришёл пакет с корректной CRC и контрольной суммой, но значение температуры и влажности некорректные, например +3.0С переданы не как 0300, а A200 +// то датчик может быть заблокирован до смены ID или до сброса погодной станциии. +// Блокировка навсегда возможна и при неправильном сочетании номера канала и ID датчика. Этот вопрос пока до конца не изучен +// +// Передача сигналов в формате RTGN318 и THGR810 до конца не протестирована. Поэтому возможны проблемы с приёмом этих сигналов погодной станцией +// на отдельных каналах