wifi_reciver.ino

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Скетч для передачи показаний с беспроводных датчиков Oregon Scientific THN132N или THGN132N на сервис “Народный Мониторинг” (narodmon.ru)
//с помощью Arduino-совместимых плат на основе ESP8266 (Wemos D1, NodeMCU).

//Для подключения необходимы:
//- Сам датчик Oregon Scientific THN132N, THGN132N, THGN123 и т.п.,
//- ПРоцессорная плата на основе ESP8266 (Wemos D1 или NodeMCU),
//- Приёмник OOK 433Мгц (Питание 3В, подключается к D7 процессорной платы),
//- WiFi подключение к Интернет
//- Arduino IDE с установленной поддержкой ESP8266-совместимых устройств и библиотекой Oregon_NR
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <Oregon_NR_MY.h>
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

//Режимы работы
#define TEST_MODE       false             //Режим отладки (данные на narodmon.ru не отсылаются)
//#undef TEST_MODE

#define SEND_INTERVAL 120000 //350000 - 5 min   //Как часто отсылать данные на сервер
#define CONNECT_TIMEOUT 10000         //Время ожидания  соединения
#define DISCONNECT_TIMEOUT 10000      //Время ожидания отсоединения

//#define mac "#FF:FF:FF:FF:FF:FF"      //МАС-адрес на narodmon.ru d8-f1-5b-07-1c-0b
//#define mac "#D8:F1:5B:07:1C:0B"      //МАС-адрес на narodmon.ru d8-f1-5b-07-1c-0b
#define mac "#ESP826677671C0B"      //МАС-адрес на narodmon.ru d8-f1-5b-07-1c-0b
//#define mac "#ESP8266FFFFFFFF"      //ID или MAC на narodmon.ru


const char* ssid = "ASUS";            //Параметры входа в WiFi
const char* password = "123456789";
//настройки сети для хитрого маршрута
//IPAddress ip(192,168,137,17);  //статический IP 
//IPAddress gateway(192,168,137,1);
//IPAddress subnet(255,255,255,0);
//IPAddress dns1(8,8,8,8);
//ESP8266WebServer server(80);
//****************************************************************************************

Oregon_NR oregon(13, 13, 2, true); // Приёмник 433Мгц подключён к D7 (GPIO13), Светодиод на D2 подтянут к +пит.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Массивы для хранения полученных данных для датчиков Oregon:
    float r_tmp[3];                //Температура
    float  r_hmdty[3];             //Влажность. Если = 101 - значит нет данных
    bool  r_bat[3], bat_pcr, bat_wrt;                //Флаг батареи
    bool  r_isreceived[3];         //Флаг о том, что по данному каналу приходил хоть один правильный пакет и данные актуальны
    
    word  r_type[3];               //Тип датчика
    unsigned long rcv_time[3];     // времена прихода последних пакетов
    float  number_of_receiving[3]; //сколько пакетов получено в процессе сбора данных
    float wa_speed;             // Скорость ветра
    float mw_speed;             // Макс скорость ветра
//    bool  w_direction;         // Направление ветра
    float w_d;                 // Направление ветра
    float r_rate;               // Интенсивность осадков - дождя
    float r_total;              // Колличество осадков - дождя
    

//****************************************************************************************
//Oregon_NR::Oregon_NR(byte MHZ, byte MHZ_INT)
//{
//  //INT_NO = MHZ_INT;
//  //RECEIVER_PIN = MHZ;
//  //pinMode(MHZ, INPUT); // Вывод, на который подключён приёмник
//  digitalWrite(MHZ, HIGH); // ДОБАВЛЕННО mr.Tech ВРЕМЕННО ТОЛЬКО ДЛЯ ОТЛАДКИ. нЕОБХОДИМО УДАЛИТЬ!
//}

#define BLUE_LED 2      //Индикация подключения к WiFi
#define GREEN_LED 14    //Индикатор успешной доставки пакета а народмон
#define RED_LED 255     //Индикатор ошибки доставки пакета на народмон


//Параметоы соединения с narodmon:
//IPAddress nardomon_server(94,19,113,221);
char nardomon_server[] = "narodmon.ru"; 
int port=8283;
WiFiClient client; //Клиент narodmon


const unsigned long postingInterval = SEND_INTERVAL; 
unsigned long lastConnectionTime = 0;                   
boolean lastConnected = false;                          
unsigned long cur_mark;


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//SETUP//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void setup()
{

    
  pinMode(BLUE_LED, OUTPUT);        
  pinMode(GREEN_LED, OUTPUT);        
  pinMode(RED_LED, OUTPUT);        
  
  

  /////////////////////////////////////////////////////
  //Инициализация памяти
  for (int i = 0; i < 3; i++)
  {
    rcv_time[i] = 7000000;
    r_isreceived[i] = 0;
    number_of_receiving[i] = 0;
  }
 
  
  /////////////////////////////////////////////////////
  //Запуск Serial-ов

  Serial.begin(115200);
  Serial.println("");
  
  if (TEST_MODE) Serial.println("Test mode");

  
  /////////////////////////////////////////////////////
  //Запуск Wifi
  

  wifi_connect();
  /////////////////////////////////////////////////////
  

  digitalWrite(BLUE_LED, HIGH);    
  if (test_narodmon_connection()){
    digitalWrite(GREEN_LED, HIGH);
    digitalWrite(RED_LED, LOW);
    
    
  }
  else {
    digitalWrite(GREEN_LED, LOW);
    digitalWrite(RED_LED, HIGH);

  }


  //вкючение прослушивания радиоканала  
  oregon.start(); 
  
  oregon.receiver_dump = true;
//Если не распознаются последние байты принятого пакета можно попробовать подстроить частоту захвата данных
  oregon.timing_correction = 0;  // коррекция частоты завхвата данных. Обычно достаоточно подобрать значение от -5 до 5
  oregon.decode_method = 3;      //или использовать метод 3 для декодирования


}
//////////////////////////////////////////////////////////////////////
//LOOP//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////

void loop() 
{
  //////////////////////////////////////////////////////////////////////
  //Защита от подвисаний/////////////////////////////////////////
  //////////////////////////////////////////////////////////////////////  
  if  (micros() > 0xFFF00000) while ( micros() < 0xFFF00000); //Висим секунду до переполнения
  if  (millis() > 0xFFFFFC0F) while ( millis() < 0xFFFFFC0F); //Висим секунду до переполнения


  //////////////////////////////////////////////////////////////////////
  //Проверка полученных данных,/////////////////////////////////////////
  //////////////////////////////////////////////////////////////////////  
  bool is_a_data_to_send = false;
  for (int i = 0; i < 3; i++){
    if (r_isreceived[i]) is_a_data_to_send = 1;                 // Есть ли данные для отправки?
  }
  
  is_a_data_to_send = 1; //Отладка!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  
  //////////////////////////////////////////////////////////////////////
  //Отправка данных на narodmon.ru/////////////////////////////////////
  //////////////////////////////////////////////////////////////////////  
  
  if (millis() - lastConnectionTime > postingInterval && is_a_data_to_send)  {
    //Обязательно отключить прослушивание канала
    oregon.stop();
    

    digitalWrite(BLUE_LED, HIGH);    
    if (send_data()){
      digitalWrite(GREEN_LED, HIGH);
      digitalWrite(RED_LED, LOW);
      
    }
    else {
      digitalWrite(GREEN_LED, LOW);
      digitalWrite(RED_LED, HIGH);
      
    }

    oregon.start();    
  
  }


  //////////////////////////////////////////////////////////////////////
  //Захват пакета,//////////////////////////////////////////////
  //////////////////////////////////////////////////////////////////////  
  oregon.capture(0);
  //
  //Захваченные данные годны до следующего вызова capture

  //////////////////////////////////////////////////////////////////////
  //ОБработка полученного пакета//////////////////////////////////////////////
  if (oregon.captured) 
  {
    //Вывод информации в Serial
    if ((oregon.sens_type == THGN132 || oregon.sens_type == THN132) && oregon.crc_c){
      Serial.print("TIME:\t");
      Serial.print(millis()/1000);
      Serial.print("sec\t");
      //if (oregon.sens_type == THGN132)  for (int q = 0;q < PACKET_LENGTH - 2; q++) Serial.print(oregon.packet[q], HEX);
      if (oregon.sens_type == THGN132)  for (int q = 0;q < PACKET_LENGTH - 1; q++) Serial.print(oregon.packet[q], HEX);
      //if (oregon.sens_type == THN132)  for (int q = 0;q < PACKET_LENGTH - 4; q++) Serial.print(oregon.packet[q], HEX);
      if (oregon.sens_type == THN132)  for (int q = 0;q < PACKET_LENGTH - 4; q++) Serial.print(oregon.packet[q], HEX);
      Serial.print(" TYPE: ");
      if (oregon.sens_type == THGN132) Serial.print("THGN132N");
      if (oregon.sens_type == THN132) Serial.print("THN132N ");
      Serial.print(" CHNL: ");
      Serial.print(oregon.sens_chnl);
      if (oregon.sens_tmp > 0 && oregon.sens_tmp < 10) Serial.print(" TMP:  ");
      if (oregon.sens_tmp < 0 && oregon.sens_tmp >-10) Serial.print(" TMP: ");
      if (oregon.sens_tmp <= -10) Serial.print(" TMP:");
      if (oregon.sens_tmp >= 10) Serial.print(" TMP: ");
      Serial.print(oregon.sens_tmp, 1);
      Serial.print("C ");
      if (oregon.sens_type == THGN132) {
        Serial.print("HUM: ");
        Serial.print(oregon.sens_hmdty, 1);
        Serial.print("%");
      }
            
      Serial.print(" BAT: ");
      if (oregon.sens_battery) Serial.print("F "); else Serial.print("e ");
      Serial.print("ID: ");
      Serial.print(oregon.sens_id, HEX);
      //Serial.print(" PACKETS: ");
      //Serial.print(oregon.packets_received);
      //Serial.print(" PROC. TIME: ");
      //Serial.print(oregon.work_time);
      //Serial.println("ms ");
      Serial.println("");
               
      byte _chnl = oregon.sens_chnl - 1;
      number_of_receiving[ _chnl]++;
      r_type[_chnl] = oregon.sens_type;
      r_bat[_chnl] = oregon.sens_battery;
      r_isreceived[_chnl] = 1;
      r_tmp[_chnl] = r_tmp[_chnl] * ((number_of_receiving[_chnl] - 1) / number_of_receiving[_chnl]) + oregon.sens_tmp / number_of_receiving[_chnl];
      r_hmdty[_chnl] = r_hmdty[_chnl] * ((number_of_receiving[_chnl] - 1) / number_of_receiving[_chnl]) + oregon.sens_hmdty / number_of_receiving[_chnl];
      rcv_time[_chnl] = millis();         
    }
    
    if (!oregon.crc_c && oregon.packets_received)
    {
      Serial.println("TIME:\t");
      Serial.print(millis()/1000);
      Serial.print("sec\t");
      for (int q = 0; q < PACKET_LENGTH - 1 ; q++) {
        if (oregon.valid_p[q] >= 0x0F) Serial.print(oregon.packet[q], HEX);
        else Serial.print("x");
      }
      Serial.println(" CORRUPTED PACKET ");
    }
  }

if (oregon.sens_type == WGR800 && oregon.crc_c){
      Serial.println("\t");
      float wnddata;
      Serial.print(" TYPE: ");
      Serial.print("WGR800");
      Serial.print(" AVG WS: ");
      Serial.print(oregon.sens_avg_ws, 1);
      Serial.print("m/s MAX WS: ");
      Serial.print(oregon.sens_max_ws, 1);
      Serial.print("m/s WDIR: "); //N = 0, E = 4, S = 8, W = 12
      Serial.print(oregon.sens_wdir);
      Serial.print(" BAT: ");
      if (oregon.sens_battery) Serial.print("F "); else Serial.print("e ");
      Serial.print("ID: ");
      Serial.print(oregon.sens_id, HEX);

      //####
      //      float wa_speed[3];             // Скорость ветра
      //      float mw_speed[3];             // Макс скорость ветра
      //      bool  w_direction[3];          // Направление ветра
      //      float r_rate[3];               // Интенсивность осадков - дождя
      //      float r_total[3];              // Колличество осадков - дождя
      //####
      byte _chnl = oregon.sens_chnl - 1;
      number_of_receiving[ _chnl]++;
      r_type[_chnl] = oregon.sens_type;
      r_bat[_chnl] = oregon.sens_battery;
      r_isreceived[_chnl] = 1;
      //r_tmp[_chnl] = r_tmp[_chnl] * ((number_of_receiving[_chnl] - 1) / number_of_receiving[_chnl]) + oregon.sens_tmp / number_of_receiving[_chnl];
      bat_wrt = oregon.sens_battery;
      wa_speed = oregon.sens_avg_ws;
      mw_speed = oregon.sens_max_ws;
      // translate rumb to direction in DEG
      switch (oregon.sens_wdir) {
        case 0: {w_d = 360; break;}   // 0-N
        case 1: {w_d = 22.5; break;}  // 1-NNE
        case 2: {w_d = 45; break;}    // 2-NE
        case 3: {w_d = 67.5; break;}  // 3-ENE
        case 4: {w_d = 90; break;}    // 4-E
        case 5: {w_d = 112.5; break;} // 5-ESE
        case 6: {w_d = 135; break;}   // 6-SE
        case 7: {w_d = 157.5; break;} // 7-SSE
        case 8: {w_d = 180; break;}   // 8-S
        case 9: {w_d = 202.5; break;} // 9-SSW
        case 10: {w_d = 225; break;}  // A-SW
        case 11: {w_d = 247.5; break;}// B-WSW
        case 12: {w_d = 270; break;}  // C-W
        case 13: {w_d = 292.5; break;}// D-WNW
        case 14: {w_d = 315; break;}  // E-NW
        case 15: {w_d = 337.5; break;}// F-NNW
      }
      rcv_time[_chnl] = millis();
    }    
    if (oregon.sens_type == PCR800 && oregon.crc_c){
      Serial.println("\t");
      float wnddata;
      Serial.print(" TYPE: ");
      Serial.print("PCR800,");
      Serial.print(" RAIN RATE: ");
      Serial.print(oregon.rain_rate, 4);
//      Serial.print(oregon.rain_rate, 3);
      //Serial.print(" | ");
      //Serial.print(oregon.rain_rate, 1);
      Serial.print(" mm/h, ");
      Serial.print(" TOTAL RAIN: ");
      Serial.print(oregon.total_rain, 5);
      //Serial.print(" | ");
      //Serial.print(oregon.total_rain, DEC);
      Serial.print(" mm, ");
      Serial.print(" BAT: ");
      if (oregon.sens_battery) Serial.print("F "); else Serial.print("e ");
      Serial.print("ID: ");
      Serial.print(oregon.sens_id, HEX);
      //Serial.print(oregon.sens_battery, HEX);
      //Serial.print(oregon.oregon_data);
      //Serial.print("checksumm = ");
      //Serial.print(oregon.crc_c, HEX);
      //Serial.print(oregon.sens_id);
      bat_pcr = oregon.sens_battery;
      r_rate = oregon.rain_rate;
      r_total = oregon.total_rain;
    }  
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//***************************************************************************************************************************************
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void wifi_connect() {
  
  Serial.println();
  Serial.print("Connecting to ");
  Serial.print(ssid);
  unsigned long cur_mark = millis();
  bool blink = 0;
  //WiFi.config(ip, gateway, subnet, dns1);     ////////// comment if dhcp 
  WiFi.begin(ssid, password);
  do {
      while (WiFi.status() != WL_CONNECTED) {
      if (blink) {
        digitalWrite(BLUE_LED, LOW);
        
      }
      else {
        digitalWrite(BLUE_LED, HIGH);

      }
      blink = !blink;
      delay(500);
      Serial.print(".");
      //Подключаемся слишком долго. Переподключаемся....
      if ((millis() - cur_mark) > CONNECT_TIMEOUT){
        blink = 0; 
        digitalWrite(BLUE_LED, HIGH);
        WiFi.disconnect();
        delay(3000);
        cur_mark = millis();
        WiFi.begin(ssid, password);
      }
    }
  } while (WiFi.status() != WL_CONNECTED);

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println(WiFi.localIP());

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool test_narodmon_connection() {
  if (client.connect(nardomon_server, port)) {  
    client.println("##");
    cur_mark = millis();
    do {
      wait_timer(10);
      if ((millis() - cur_mark) > CONNECT_TIMEOUT) {
        Serial.println("narodmon.ru is not responding");
        client.stop();
        return 0;
      }
    } while (!client.connected());
    Serial.println("narodmon.ru is attainable");
    client.stop();
    return 1;
  } 
  else {
    Serial.println("connection to narodmon.ru failed");
    client.stop();
    return 0;
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool send_data() {

  //Если соединения с сервером нет, по переподключаемся
  if (WiFi.status() != WL_CONNECTED) wifi_connect();
  
  bool what_return = false;
  if (client.connect(nardomon_server, port)) {  
    //Отправляем MAC-адрес
    Serial.println(' ');
    String s = mac;
    Serial.print(s);
    if (!TEST_MODE) client.print(s);
//    if (TEST_MODE) Serial.println(s);
//    if (TEST_MODE) Serial.println("YOU IN TEST MODE !!!!!!!!!!!");
//    if (TEST_MODE) Serial.println("YOU IN TEST MODE !!!!!!!!!!!");
//    if (!TEST_MODE) Serial.println("YOU ARE NOT IN THE TEST MODE !!!!!!!!!!!");
    //Отправляем данные Oregon
    sendOregonData();
        
    //Завершаем передачу
    client.print("##");
    Serial.println("##");
    //Ждём отключения клиента
    cur_mark = millis();
    do {
      yield();
      if (millis() > cur_mark + DISCONNECT_TIMEOUT) break;
    } while (!client.connected());
      
    Serial.println(' ');
    client.stop();
    what_return = true;
  } 
  else {
    Serial.println("connection to narodmon.ru failed");
    client.stop();
  }
  lastConnectionTime = millis();

  //Обнуляем флаги полученных данных
  for (int i = 0; i < 3; i++) {
    r_isreceived[i] = 0;
    number_of_receiving[i] = 0;
  }
  
  return what_return;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void sendOregonData() {
//   float rain_deviation, rain_deviation_2;
//   rain_deviation = random(1, 3) * 0.001;
//   rain_deviation_2 = random(1, 3) * 0.0001;
  
    String s;
    //  WRT800 wind average speed ####
    s = "\n#WS1#";
    s += (float)wa_speed;
    Serial.println(s);
    if (!TEST_MODE) client.print(s);
    
    //  WRT800 max wind speed ########
    s = "\n#WS2#";
    s += mw_speed;
    Serial.print(s);
    if (!TEST_MODE) client.print(s);

    //  WRT800 wind direction #########
    w_d += random(-1, 1) * 0.01; //added deviation 
    s = "\n#DIR#";
    s += w_d;
    //was encoded  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
    Serial.println(s);
    if (!TEST_MODE) client.print(s);
    // v battery
    s = "\n#VBAT1#";
    switch (bat_wrt) {
        case 1: {s += " 99"; break;} 
        default: s += " 50";
    }
//    s += bat_;
    Serial.println(s);
    if (!TEST_MODE) client.print(s);
    //#####################################
    
    //  PCR800 rain deviation - especially for narodmon.ru #######################################
    //  float rain_deviation; // rain_deviation
    //  r_rate = oregon.rain_rate;
    //  r_total = oregon.total_rain;
    //  rain_deviation = random(1, 3) * 0.0025;
    //  total_rain_deviation = random(1, 3) * 0.0001;
    
    //  PCR800  rain rate ########################################################################
    s = "\n#RAIN1#";
    //    r_rate += rain_deviation; // addin deviation of last digit - .00$ - important for narodmon.ru 
    r_rate += random(0, 3) * 0.0026;
    s += String(r_rate, 4);   // show .000 digits - important for narodmon.ru
    Serial.println(s);
    if (!TEST_MODE) client.print(s);
    //  PCR800  total rain ######################################################################
    s = "\n#RAIN2#";
    //    r_total += rain_deviation;
    r_total += random(0, 3) * 0.0026;
    s += String(r_total, 4); // show .0000 digits - for narodmon.ru
    Serial.println(s);
    if (!TEST_MODE) client.print(s);
    // v battery
    s = "\n#VBAT2#";
    //s += bat_;
    switch (bat_pcr) {
        case 1: {s += " 99"; break;} 
        default: s += " 50";
    }
    Serial.println(s);
    if (!TEST_MODE) client.print(s);
    //    ########################################################################################

    
//  if (r_isreceived[0]) {
//    s = "\n#T1#";
//    s += r_tmp[0];
//    if (r_hmdty[0] > 0 && r_hmdty[0] <= 100 ){
//      s += "\n#H1#";
//      s += r_hmdty[0];
//    }
//    Serial.println(s);
//    if (!TEST_MODE) client.println(s);
//
//  }
//  if (r_isreceived[1]) {
//    s = "\n#T2#";
//    s += r_tmp[1];
//    if (r_hmdty[1] > 0 && r_hmdty[1] <= 100 ){
//      s += "\n#H2#";
//      s += r_hmdty[1];
//    }
//     s += "\n#W1#";
//    s += "0.1 m/s";
//    Serial.println(s);
//    if (!TEST_MODE) client.println(s);
//  }
//  if (r_isreceived[2]) {
//    s = "\n#T3#";
//    s += r_tmp[2];
//    if (r_hmdty[2] > 0 && r_hmdty[2] <= 100 ){
//      s += "\n#H3#";
//      s += r_hmdty[2];
//    }
//     s += "\n#W1#";
//    s += "0.3 m/s";
//    Serial.println(s);
//    if (!TEST_MODE) client.println(s);
//  }
}
////////////////////////////////////////////////////////////////////////////////////////
// ЗАМЕНА DELAY, которая работает и не приводит к вылету...
////////////////////////////////////////////////////////////////////////////////////////
void wait_timer(int del){
  unsigned long tm_marker = millis();
  while (millis() - tm_marker < del) yield();
  return;
    
}