Pushover script


#1

Hallo zusammen,
habe ein pushover (https://pushover.net/) skript eingebunden. Dieses ist zwar soweit funktional, wenn es nun im setup aufgerufen wird (pushover(“sensebox started”,0);), erfolgt ein Push, aber die Sensebox hängt komplett und läuft nicht weiter. Fehler im Skript oder weitere Ideen?
Danke

/******** Pushover ********/
String po_token  = "xxxxxxxxxx";   // Pushover Token
String po_user   = "xxxxxxxxxx";   // Pushover User
String po_retry  = "60";         //wie hauefig eine Nachricht vom Server geschickt wird
String po_expire = "3600";       
String po_sound  = "spacealarm";  //Sounds: pushover, bike, bugle, cashregister, classical, cosmic, falling, gamelan, incoming, intermission, magic, mechanical, pianobar, siren, spacealarm, tugboat, alien, climb, persistent, echo, updown, none

WiFiClient POclient;

/******** START Pushover ********/
/*Prioritaeten: 0=Normal; 1=High (AudioVibration auch bei quiet hour); 2=Emergency (Meldung muss bestätigt werden, solange Sound/Vibration); 
 *  -1=Low ; -2=Lowest, dabei length anpassen auf 114 
*/  

void pushover(String pushovermessage, int po_prio) {
  int length;
  String Msg = pushovermessage;
  length = 113 + Msg.length();
  DEBUG("[pushover] sending message");
  if (POclient.connect("api.pushover.net", 80)) {
      POclient.println("POST /1/messages.json HTTP/1.1");
      POclient.println("Host: api.pushover.net");
      POclient.println("Connection: close\r\nContent-Type: application/x-www-form-urlencoded");
      POclient.print("Content-Length: ");
      POclient.print(length);
      POclient.println("\r\n");
      POclient.print("token="+po_token+"&user="+po_user+"&message="+Msg+"&priority="+po_prio+"&retry="+po_retry+"&expire="+po_expire);
      /*POclient.print("&sound="+po_sound);      //!length anpassen! +7+ */
      /*POclient.print("&device="+po_device);    //!length anpassen! +8+ */
      while(POclient.connected())  
      {
        while(POclient.available())
        {
        char ch = POclient.read();
        Serial.write(ch);
        }
      }
    POclient.stop();
    DEBUG("[pushover] sending message done");
    delay(200);  
  }
}
/******** END Pushover ********/

Telegram Bot - kein Connect
#2

Hi,

das ist anhand des Code Ausschnitt schwierig zu sagen wo ein Problem auftritt. Stelle doch bitte einmal deinen vollständigen Code hier rein.

Viele Grüße
Mario


#3

Klar. Gerne. Danke.

const char CodeVersion[] = "CodeVersion v4.0 - 20200620";

#include <SenseBoxMCU.h>
#include <SPI.h>
#include <Wire.h>
#include <WiFiSSLClient.h>
#include <WiFi101.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_GFX.h>
#include <Adafruit_BME680.h>
#include <LoraMessage.h>
#include <lmic.h>
#include <hal/hal.h>
#include <UniversalTelegramBot.h>

// Debugging messages on Serial port
// Do not leave this enabled for long time use
// #define ENABLE_DEBUG

#ifdef ENABLE_DEBUG
  #define DEBUG(str) Serial.println(str)
  #define DEBUG_ARGS(str,str1) Serial.println(str,str1)
  #define DEBUG2(str) Serial.print(str)
  #define DEBUG_WRITE(c) Serial.write(c)
 #else
  #define DEBUG(str)
  #define DEBUG_ARGS(str,str1)
  #define DEBUG2(str)
  #define DEBUG_WRITE(c)
#endif

bool DEBUG_DATA;
const int ledPin = 7;     //red LED onboard senseBoxMCU

/******** Timing ********/
// Intervall SDS/PM
const long pm_interval = 31000;
long pm_time_start  = 0;
long pm_time_actual = 0;

// Intervall BME
const long bme_interval = 27000;
long bme_time_start  = 0;
long bme_time_actual = 0;

// Intervall Light
const long li_interval = 25000;
long li_time_start  = 0;
long li_time_actual = 0;

// Intervall CO2
const long co2_interval = 28000;
long co2_time_start  = 0;
long co2_time_actual = 0;

// Intervall openSenseMap
const long osm_interval = 62000;
long osm_time_start  = 0;
long osm_time_actual = 0;

// Intervall TelegramBot
const long tbot_interval = 85000;
long tbot_time_start  = 0;
long tbot_time_actual = 0;

/******** Sensor Bibliothek ********/
float temperature;           // Temperatur
float humidity;              // Feuchtigkeit
float pressure, pressure_Pa; // Luftdruck in hPa
float voc;                   // Gas/Luftqualität
float est_altitude;          // Höhe (ca.)

#define SEALEVELPRESSURE_HPA (1024)

/******** Adafruit BME680 Bibliothek ********/
Adafruit_BME680 bme680;           // Zugriff ueber I2C

/******** Lichtintensität TSL45315 & UV-Strahlung VEML6070 ********/
//Makerblog_TSL45315 tsl = Makerblog_TSL45315(TSL45315_TIME_M4);
TSL45315 tsl;
unsigned long lux; // Lichtstärke
VEML6070 veml;
unsigned int uv;
byte uvindex;// UV-Index

/******** Adafruit Feinstaub SDS011 ********/
// Load SDS011 Sensor on Serial 1
SDS011 sds(Serial1);
float pm10, pm10_n, pm25, pm25_n;

/******** Seeed Studio Grove CO2 MH-Z16 ********/
// Load CO2 Sensor on Serial 2
#define GROVE_CO2 (Serial2)
const unsigned char cmd_get_sensor[] = {0xff, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79};
unsigned char dataReceived[9];
uint8_t attempt = 0;
int temperature_co2;
unsigned int co2ppm;

// Helper function for co2 sensor
int dataReceive(void)
{
  byte data[9];
  int i = 0;
  //transmit command data
  for(i=0; i<sizeof(cmd_get_sensor); i++)
  {
    GROVE_CO2.write(cmd_get_sensor[i]);
  }
  delay(10);
  //begin receiving data
  if(GROVE_CO2.available())
    {
    while(GROVE_CO2.available())
      {
        for(int i=0;i<9; i++)
        {
          data[i] = GROVE_CO2.read();
        }
      }
    }
  delay(100);
  if((i != 9) || (1 + (0xFF ^ (byte)(data[1] + data[2] + data[3] + data[4] + data[5] + data[6] + data[7]))) != data[8])
    {
      DEBUG("ERROR - GROVE_CO2 Check.value");
      return false;
    }
    co2ppm = (int)data[2] * 256 + (int)data[3];
    temperature_co2 = (int)data[4] - 40;
    return co2ppm;
}

/******** WLAN WiFi-Bee WINC1500 am XBEE1 mit fester IP-Adresse ********/
char wifi_ssid[]  = "xxxxx";             // network wifi_ssid (name)
char wifi_psk[]   = "xxxxx";   // network psk-key
IPAddress myip(x,x,x,x);
IPAddress mydns(x,x,x,x);
IPAddress mygateway(x,x,x,x);
IPAddress mysubnet(255, 255, 255, 0);

/******** LoRaWAN LoRa-Bee RFM9X am XBEE2 ********/
// Schedule TX every this many seconds (might become longer due to duty cycle limitations)
const unsigned TX_INTERVAL = 65;

//OTAA
// This EUI must be in little-endian format, so least-significant-byte (lsb)
// first. When copying an EUI from ttnctl output, this means to reverse the bytes.
static const u1_t PROGMEM DEVEUI[8] = { 0x00 ...};
void os_getDevEui (u1_t* buf) { memcpy_P(buf, DEVEUI , 8);}

// This EUI must be in little-endian format, so least-significant-byte (lsb)
// first. When copying an EUI from ttnctl output, this means to reverse
// the bytes. For TTN issued EUIs the last bytes should be 0xD5, 0xB3, 0x70.
static const u1_t PROGMEM APPEUI[8] = { 0x00 ...};
void os_getArtEui (u1_t* buf) { memcpy_P(buf, APPEUI , 8);}

// This key should be in big endian format (msb) (or, since it is not really 
// a number but a block of memory, endianness does not really apply).
// In practice, a key taken from ttnctl can be copied as-is.
static const u1_t PROGMEM APPKEY[16] = { 0x00 ...};
void os_getDevKey (u1_t* buf) {  memcpy_P(buf, APPKEY , 16);}

static uint8_t mydata[] = "Hi,Lora World!"; //for testing
static osjob_t sendjob;

// Pin mapping
const lmic_pinmap lmic_pins = {
  .nss = PIN_XB2_CS,
  .rxtx = LMIC_UNUSED_PIN,
  .rst = LMIC_UNUSED_PIN,
  .dio = {PIN_XB2_INT, PIN_XB2_INT, LMIC_UNUSED_PIN},
};

/******** OpenSenseMap ********/
WiFiClient client;

// address of the server to send to
const char server[] PROGMEM = "ingress.opensensemap.org";

// senseBox ID
const char SENSEBOX_ID[] PROGMEM = "xxxxxxxxxx";

// Number of sensors
// Change this number if you add or remove sensors do not forget to remove or add the sensors on opensensemap.org
static const uint8_t NUM_SENSORS = 10;

// sensor IDs
// Temperatur
const char TEMPERSENSOR_ID[] PROGMEM = "xxxxxxxxxx";
// rel. Luftfeuchte
const char RELLUFSENSOR_ID[] PROGMEM = "xxxxxxxxxx";
// Luftdruck
const char LUFTDRSENSOR_ID[] PROGMEM = "xxxxxxxxxx";
// Beleuchtungsstärke
const char BELEUCSENSOR_ID[] PROGMEM = "xxxxxxxxxx";
// UV-Intensität
const char UVINTESENSOR_ID[] PROGMEM = "xxxxxxxxxx";
// UV-Index
const char UVINDESENSOR_ID[] PROGMEM = "xxxxxxxxxx";
// PM10
const char PM10SENSOR_ID[] PROGMEM = "xxxxxxxxxx";
// PM2.5
const char PM25SENSOR_ID[] PROGMEM = "xxxxxxxxxx";
// VOC
const char VOCSENSOR_ID[] PROGMEM = "xxxxxxxxxx";
// CO2
const char CO2SENSOR_ID[] PROGMEM = "xxxxxxxxxx";

typedef struct measurement 
{
  const char *sensorId;
  float value;
} 
  measurement;

measurement measurements[NUM_SENSORS];
uint8_t num_measurements = 0;

// buffer for sprintf
char buffer[1500];

/******** Telegram BOT ********/
#define BOTtoken "xxxxxxxxxx"    // your Bot Token (Get from Botfather)

WiFiSSLClient BOTclient;
UniversalTelegramBot bot(BOTtoken, BOTclient);

int Bot_mtbs = 1000;        // mean time between scan messages
long Bot_lasttime;           // last time messages' scan has been done
bool Start = false;

/******** Pushover ********/
String po_token  = "xxxxxxxxxx";   // Pushover Token
String po_user   = "xxxxxxxxxx";   // Pushover User
String po_retry  = "60";         //wie hauefig eine Nachricht vom Server geschickt wird
String po_expire = "3600";       
String po_sound  = "spacealarm"; //Sounds: pushover, bike, bugle, cashregister, classical, cosmic, falling, gamelan, incoming, intermission, magic, mechanical, pianobar, siren, spacealarm, tugboat, alien, climb, persistent, echo, updown, none

WiFiClient POclient;

/******** START serial debug ********/
void serial_debug(void)
{
  
  Serial.print("Temperatur = ");
  Serial.print(temperature);
  Serial.println(" °C");

  Serial.print("Feuchtigkeit = ");
  Serial.print(humidity);
  Serial.println(" %");

  Serial.print("Luftdruck = ");
  Serial.print(pressure);
  Serial.println(" hPa");

  Serial.print("Beleuchtungsstärke = ");
  Serial.print(lux);
  Serial.println(" lx");

  Serial.print("UV-Intensität = ");
  Serial.print(uv);
  Serial.print(" μW/cm²");
  Serial.print(" / UV-Index = ");
  Serial.println(uvindex);

  Serial.print("PM10 = ");
  Serial.print(pm10);
  Serial.print(" µg/m³");
  Serial.print(" / normalized = ");
  Serial.print(pm10_n);
  Serial.println(" µg/m³");

  Serial.print("PM2.5 = ");
  Serial.print(pm25);
  Serial.print(" µg/m³");
  Serial.print(" / normalized = ");
  Serial.print(pm25_n);
  Serial.println(" µg/m³");

  Serial.print("VOC = ");
  Serial.print(voc);
  Serial.println(" kOhm");

  Serial.print("CO2 = ");
  Serial.print(co2ppm);
  Serial.println(" ppm");
  
  Serial.print("Höhe (ca.) = ");
  Serial.print(est_altitude);
  Serial.println(" m");

  Serial.println();
}
/******** END serial debug ********/

/******** START bme/bmp/hdc measurement ********/
void measure_bme(void)
{
  DEBUG("[measure] bme");
  // bme680 auslesen, Werte ermitteln und merken
  bme680.setGasHeater(0, 0);
  if ( bme680.performReading())
  {
    temperature  = bme680.temperature - 1;
    humidity     = bme680.humidity;
    pressure     = bme680.pressure / 100.0;
    pressure_Pa  = bme680.pressure;
    est_altitude = bme680.readAltitude(SEALEVELPRESSURE_HPA);
  }
  delay(500);
  bme680.setGasHeater(320, 150); // 320*C for 150 ms
  if ( bme680.performReading())
  {
    voc = bme680.gas_resistance / 1000.0;
  }
  delay(1000);
}
/******** END bme/bmp/hdc measurement ********/

/******** START tsl/veml (light) measure ********/
void measure_light(void)
{
  DEBUG("[measure] light");
  lux           = tsl.getIlluminance();
  uv            = veml.getUvIntensity();
  uvindex       = 0.4 * (uv * 5.625) / 1000;
}
/******** END tsl/veml measure ********/

/******** START SDS011 (PM) measure ********/
void measure_pm(void)
{
  DEBUG("[measure] pm");
  uint8_t attempt_pmread = 0;
  while (attempt_pmread < 5)
  {
    pm25   = sds.getPm25();
    pm10   = sds.getPm10();
    break;
    attempt_pmread++;
  }
 
  pm25_n = pm25 / (1.0 + 0.48756 * pow((humidity / 100.0), 8.60068));
  pm10_n = pm10 / (1.0 + 0.81559 * pow((humidity / 100.0), 5.83411));
}
/******** END sds measure ********/

/******** START measurement serial2 Grove CO2 ********/
void measure_co2(void)
{
  DEBUG("[measure] co2");
  uint8_t attempt_co2 = 0;
  while (attempt_co2 < 5) 
  {
    bool error_co2 = dataReceive();
    if (error_co2 != 0) {
      break;
    }
    attempt_co2++;
  }
}

/******** START OpenSenseMap ********/
void addMeasurement(const char *sensorId, float value) {
  measurements[num_measurements].sensorId = sensorId;
  measurements[num_measurements].value = value;
  num_measurements++;
}

void writeMeasurementsToClient() {
  // iterate throug the measurements array
  for (uint8_t i = 0; i < num_measurements; i++) {
    sprintf_P(buffer, PSTR("%s,%9.2f\n"), measurements[i].sensorId,
              measurements[i].value);

    // transmit buffer to client
    client.print(buffer);
    DEBUG2(buffer);
  }

  // reset num_measurements
  num_measurements = 0;
}

void submitValues() {
  // close any connection before send a new request - free the socket on the WiFi shield
  if (client.connected()) {
    client.stop();
    delay(1000);
  }
  bool connected = false;
  char _server[strlen_P(server)];
  strcpy_P(_server, server);
  for (uint8_t timeout = 5; timeout != 0; timeout--) {
    DEBUG("[oSM] connecting...");
    connected = client.connect(_server, 80);
    if (connected == true) {
      DEBUG("[oSM] connection successful, transferring...");
      DEBUG();
      
      // construct the HTTP POST request:
      sprintf_P(buffer,
                PSTR("POST /boxes/%s/data HTTP/1.1\nHost: %s\nContent-Type: "
                     "text/csv\nConnection: close\nContent-Length: %i\n\n"),
                SENSEBOX_ID, server, num_measurements * 35);
      DEBUG(buffer);

      // send the HTTP POST request:
      client.print(buffer);

      // send measurements
      writeMeasurementsToClient();

      // send empty line to end the request
      client.println();

      uint16_t timeout = 0;
      // allow the response to be computed
      while (timeout <= 5000) {
        delay(10);
        timeout = timeout + 10;
        if (client.available()) {
          break;
        }
      }

      DEBUG();
      while (client.available()) {
        char c = client.read();
        DEBUG_WRITE(c);
        // if the server's disconnected, stop the client:
        if (!client.connected()) {
          DEBUG();
          DEBUG("[oSM] disconnecting...");
          client.stop();
          break;
        }
      }

      DEBUG();
      DEBUG("[oSM] done");
      DEBUG();
      
      // reset number of measurements
      num_measurements = 0;
      break;
   }
    delay(2000);
  }

  if (connected == false) {
    // Reset durchführen
    DEBUG("ERROR - Connection oSM failed. Restarting System.");
    senseBoxIO.powerNone();       // all ports off
    delay(500);
    noInterrupts();
    NVIC_SystemReset();
    while (1);
  }
}

void senddataOSM(void)
{
  addMeasurement(TEMPERSENSOR_ID, temperature);
  addMeasurement(RELLUFSENSOR_ID, humidity);
  addMeasurement(LUFTDRSENSOR_ID, pressure);
  addMeasurement(BELEUCSENSOR_ID, lux);
  addMeasurement(UVINTESENSOR_ID, uv);
  addMeasurement(UVINDESENSOR_ID, uvindex);
  addMeasurement(PM10SENSOR_ID, pm10);
  addMeasurement(PM25SENSOR_ID, pm25);
  addMeasurement(VOCSENSOR_ID, voc);
  addMeasurement(CO2SENSOR_ID, co2ppm);
  submitValues();
}
/******** END OpenSenseMap ********/

/******** START LoRa ********/
void onEvent(ev_t ev) 
{
  senseBoxIO.statusGreen();
  DEBUG2(os_getTime());
  DEBUG2(": ");
  switch(ev) {
    case EV_SCAN_TIMEOUT:
      DEBUG("[LoRa] EV_SCAN_TIMEOUT");
      break;
    case EV_BEACON_FOUND:
      DEBUG("[LoRa] EV_BEACON_FOUND");
      break;
    case EV_BEACON_MISSED:
      DEBUG("[LoRa] EV_BEACON_MISSED");
      break;
    case EV_BEACON_TRACKED:
      DEBUG("[LoRa] EV_BEACON_TRACKED");
      break;
    case EV_JOINING:
      DEBUG("[LoRa] EV_JOINING");
      break;
    case EV_JOINED:
      DEBUG("[LoRa] EV_JOINED");
      // Disable link check validation (automatically enabled during join, but not supported by TTN at this time).
      LMIC_setLinkCheckMode(0);
      break;
    case EV_RFU1:
      DEBUG("[LoRa] EV_RFU1");
      break;
    case EV_JOIN_FAILED:
      DEBUG("[LoRa] EV_JOIN_FAILED");
      break;
    case EV_REJOIN_FAILED:
      DEBUG("[LoRa] EV_REJOIN_FAILED");
      break;
    case EV_TXCOMPLETE:
      DEBUG("[LoRa] EV_TXCOMPLETE (includes waiting for RX windows)");
      if (LMIC.txrxFlags & TXRX_ACK)
        DEBUG("Received ack");
      if (LMIC.dataLen) 
      {
        DEBUG2("[LoRa] Received ");
        DEBUG2(LMIC.dataLen);
        DEBUG(" bytes of payload");
      }
      // Schedule next transmission
      os_setTimedCallback(&sendjob, os_getTime()+sec2osticks(TX_INTERVAL), do_send);
      break;
    case EV_LOST_TSYNC:
      DEBUG("[LoRa] EV_LOST_TSYNC");
      break;
    case EV_RESET:
      DEBUG("[LoRa] EV_RESET");
      break;
    case EV_RXCOMPLETE:
      // data received in ping slot
      DEBUG("[LoRa] EV_RXCOMPLETE");
      break;
    case EV_LINK_DEAD:
      DEBUG("[LoRa] EV_LINK_DEAD");
      break;
    case EV_LINK_ALIVE:
      DEBUG("[LoRa] EV_LINK_ALIVE");
      break;
    default:
      DEBUG2("[LoRa] Unknown event");
      DEBUG((unsigned) ev);
      break;
  }
  senseBoxIO.statusNone();
}

void do_send(osjob_t* j) 
{
  senseBoxIO.statusRed();
  // Check if there is not a current TX/RX job running
  if (LMIC.opmode & OP_TXRXPEND) 
    {
    DEBUG("[LoRa] OP_TXRXPEND, not sending");
    } else {
    DEBUG("[LoRa] Prepare Message");
    LoraMessage message;
      
    DEBUG2("[LoRa] Temperature): ");
    DEBUG(temperature);
    message.addUint16((temperature + 18) * 771);
    delay(200);

    DEBUG2("[LoRa] Humidity: ");
    DEBUG(humidity);
    message.addHumidity(humidity);
    delay(200);

    DEBUG2("[LoRa] Pressure: ");
    DEBUG(pressure);
    message.addUint16((pressure - 300) * 81.9187);
    delay(200);

    DEBUG2("[LoRa] Illuminance: ");
    DEBUG(lux);
    message.addUint8(lux);
    message.addUint16(lux >> 8);
    delay(200);
  
    DEBUG2("[LoRa] UV: ");
    DEBUG(uv);
    message.addUint8(uv);
    message.addUint16(uv >> 8);
    DEBUG2("[LoRa] UV-Index: ");
    DEBUG(uvindex);
    message.addUint16(uvindex * 10);
    delay(200);
  
    DEBUG2("[LoRa] PM10: ");
    DEBUG(pm10);
    message.addUint16(pm10 * 10);
    DEBUG2("[LoRa] PM2.5: ");
    DEBUG(pm25);
    message.addUint16(pm25 * 10);
    delay(200);

    DEBUG2("[LoRa] VOC: ");
    DEBUG(voc);
    message.addUint16(voc * 10);
    delay(200);
    
    DEBUG2("[LoRa] CO2 PPM: ");
    DEBUG(co2ppm);
    message.addUint16(co2ppm * 10);
    delay(200);
      
    // prepare upstream data transmission at the next possible time.
    // transmit on port 1 (the first parameter); you can use any value from 1 to 223 (others are reserved).
    // don't request an ack (the last parameter, if not zero, requests an ack from the network).
    // Remember, acks consume a lot of network resources; don't ask for an ack unless you really need it.
    LMIC_setTxData2(1, message.getBytes(), message.getLength(), 0);
 //   LMIC_setTxData2(1, mydata, sizeof(mydata)-1, 1);
    DEBUG("[LoRa] packet queued");DEBUG(" ");
  }
 // Next TX is scheduled after TX_COMPLETE event
  senseBoxIO.statusNone();
}
/******** END LoRa ********/

/******** START Telegram BOT ********/
void handleNewMessages(int numNewMessages)
{
  DEBUG2("handleNewMessages");
  DEBUG(String(numNewMessages));
  String response;
  for (int i = 0; i < numNewMessages; i++) {
    String chat_id = String(bot.messages[i].chat_id);
    String text = bot.messages[i].text;
    if (text == "/readTemp") {
      response = "Temp ";
      response += String(temperature);
      response += " °C mit ";
      response += String(humidity);
      response += " % Luftfeuchtigkeit bei ";
      response += String(pressure);
      response += " hPa Luftdruck";

      if (temperature > 26 && temperature <= 124) {
        response += " \xF0\x9F\x94\xA5";
      } else if (temperature < 6) {
        response += " \xE2\x9D\x84";
      } else if (temperature > 124) {
        response = "ERROR reading sensor. Check if sensor is connected or replace cable/sensor.";
      } else {
        response += ".";
      }
      bot.sendMessage(chat_id, response, "");
    }
    if (text == "/readPM") {
      response = "PM10 = ";
      response += String(pm10);
      response += " & PM2.5 = ";
      response += String(pm25);
      response += ".";
      bot.sendMessage(chat_id, response, "");
    }
    if (text == "/readLight") {
      response = "Beleuchtungsstärke = ";
      response += String(lux);
      response += " lx";
      response += " & UV-Intensität = ";
      response += String(uv);
      response += " μW/cm²";
      response += " & UV-Index = ";
      response += String(uvindex);
  
      if (uvindex >= 0 && uvindex < 3) {
        response += " \xF0\x9F\x8C\x83 \xF0\x9F\x8C\x85 \xE2\x98\x81";
      } else if (uvindex >= 3 && uvindex <= 5.5) {
        response += " \xE2\x9B\x85";
      } else if (uvindex >= 5.6 && uvindex <= 7.5) {
        response += " \xE2\x98\x80";      
      } else if (uvindex >= 7.6 && uvindex <= 10.5) {
        response += " \xE2\x98\x80 \xE2\x98\x80"; 
      } else if (uvindex > 10.6) {
        response += "\xE2\x98\x80 \xE2\x98\x80";
      } else {
        response += ".";
      }
      bot.sendMessage(chat_id, response, "");
    }
    if (text == "/readCO2") {
      response = "CO² = ";
      response += String(co2ppm);
      response += " ppm";
      response += ".";
      bot.sendMessage(chat_id, response, "");
    }
     if (text == "/start") {
      String from_name = bot.messages[i].from_name;
      if (from_name == "") from_name = "Anonymous";

      String welcome = "Welcome, " + from_name + "! This is your fancy senseBoxMCU bot \xF0\x9F\x91\xBD\n\n";
      welcome = welcome + "Use /status to read HDC1080 sensor measurements.\n";
      bot.sendMessage(chat_id, welcome, "Markdown");
      
      String keyboardJson = "[[\"/readTemp\"],[\"/readLight\"],[\"/readPM\"],[\"/readCO2\"]]";
      bot.sendMessageWithReplyKeyboard(chat_id, "Select a function from the keyboard", "", keyboardJson, true);
    }
  }
}

void senddataTGBot(void)
{
  if (millis() > Bot_lasttime + Bot_mtbs)  {
    DEBUG();
    DEBUG("[TBot] data to...");  
    int numNewMessages = bot.getUpdates(bot.last_message_received + 1);
    while (numNewMessages) {
      DEBUG2("[TBot] got response ");
      handleNewMessages(numNewMessages);
      numNewMessages = bot.getUpdates(bot.last_message_received + 1);
    }
    Bot_lasttime = millis();
  }
}
/******** END Telegram BOT ********/

/******** START Pushover ********/
/*Prioritaeten: 0=Normal; 1=High (AudioVibration auch bei quiet hour); 2=Emergency (Meldung muss bestätigt werden, solange Sound/Vibration); 
 *  -1=Low ; -2=Lowest, dabei length anpassen auf 114 
 *  
*/
byte pushover(String pushovermessage, int po_prio) {
  int length;
  String Msg = pushovermessage;
  length = 113 + Msg.length();
  DEBUG("[pushover] sending message");
  if (POclient.connect("api.pushover.net", 80)) {
      POclient.println("POST /1/messages.json HTTP/1.1");
      POclient.println("Host: api.pushover.net");
      POclient.println("Connection: close\r\nContent-Type: application/x-www-form-urlencoded");
      POclient.print("Content-Length: ");
      POclient.print(length);
      POclient.println("\r\n");
      POclient.print("token="+po_token+"&user="+po_user+"&message="+Msg+"&priority="+po_prio+"&retry="+po_retry+"&expire="+po_expire);
      /*POclient.print("&sound="+po_sound);      //!length anpassen! +7+ */
      /*POclient.print("&device="+po_device);    //!length anpassen! +8+ */
      while(POclient.connected())  
      {
        while(POclient.available())
        {
        char ch = POclient.read();
        Serial.write(ch);
        }
      }
    POclient.stop();
    DEBUG("[pushover] sending message done");
    delay(200);  
  }
}
/******** END Pushover ********/

/******** START setup ********/
void setup()
{
  DEBUG_DATA = false;
  senseBoxIO.powerNone();       // all ports off 

// ledPIN
  pinMode(ledPin, OUTPUT);      // initialize digital ledPin as an output.
  delay(100);
  digitalWrite(ledPin, LOW);    // initialize pin as off

  // Initialize serial and wait for port to open:
  #ifdef ENABLE_DEBUG
    Serial.begin(9600);
  #endif
  delay(2000);

  Serial.println();
  Serial.println(CodeVersion);
  Serial.println();
  Serial.println("[INIT] start...");
  
  // Sensor initialization
  Serial.print("[INIT] sensors");
  delay(1000);

  Serial.print(".");
  // Wifi-Bee in XBEE1 Socket
  senseBoxIO.powerXB1(false);
  delay(250);
  senseBoxIO.powerXB1(true);
  Serial.print(".");
  delay(2000);
  
  Serial.print(".");
  // RFM9X (LoRa-Bee) in XBEE2 Socket
  senseBoxIO.powerXB2(false); // power off to reset RFM9X
  delay(250);
  senseBoxIO.powerXB2(true);  // power on
  pinMode(PIN_XB2_INT, INPUT_PULLDOWN); // pull-down because interrupt is high-active 
  Serial.print(".");
  delay(2000);

  Serial.print(".");  
  senseBoxIO.powerI2C(true);
  delay(2000);
  senseBoxIO.powerUART(true);
  Serial.print(".");
  delay(2000);

  Serial.print(".");
    // init TSL 0x38 Beleuchtungsstärke
  tsl.begin();
  delay(1000);
  // init VEML 0x38+0x39 UV-Strahlung
  veml.begin();
  Serial.print(".");  
  delay(1000);

  Serial.print(".");
  // init BME680 (Umweltsensor) BME 0x76
  bme680.begin(0x76);
   // Initialisierung von Oversampling und Filter
  bme680.setTemperatureOversampling(BME680_OS_8X);
  bme680.setHumidityOversampling(BME680_OS_2X);
  bme680.setPressureOversampling(BME680_OS_4X);
  bme680.setIIRFilterSize(BME680_FILTER_SIZE_3);
  delay(1000);
  Serial.print(".");  
  bme680.setGasHeater(320, 150); // 320*C for 150 ms
  if ( bme680.performReading())
  {
    voc = bme680.gas_resistance / 1000.0;
  }
  delay(1000);

  Serial.print(".");  
  // init SDS011
  Serial1.begin(9600);
  delay(5000);
  //damit keine Nullwerte
  pm25   = sds.getPm25();
  pm10   = sds.getPm10();
  Serial.print(".");  
  delay(1000);

  Serial.print(".");
  // init Grove CO2 (MH-Z16)
  GROVE_CO2.begin(9600);      //= Serial2.begin(9600);
  delay(5000);
  measure_co2();
  delay(2000);
  
  Serial.println(".");
  Serial.println("[INIT] sensors done");

  // Messungen um nicht Werte=0
  measure_bme();
  measure_light();
  measure_pm();
  measure_co2();
  delay(5000);
  
  // attempt to connect to WiFi network
  Serial.print("[INIT] WLAN");
  Serial.print(".");
  WiFi.begin(wifi_ssid, wifi_psk);
  WiFi.config(myip, mydns, mygateway, mysubnet);
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
  }
  Serial.println(); Serial.println("[INIT] WLAN done");  
  delay(2000);

  // init LoRa-WAN
  Serial.print("[INIT] LoRa-WAN");
  // initialize LMIC - runtime env
  Serial.print(".");
  os_init();
  Serial.print(".");
  // Reset the MAC state. Session and pending data transfers will be discarded    
  LMIC_reset();
  Serial.println(); Serial.println("[INIT] LoRa-WAN done");
  delay(2000);
  
//  pushover("sensebox#1 started",0);
     
  // Start job (sending automatically starts OTAA too)
  do_send(&sendjob);
}
/******** END setup ********/

/******** loop() ********/
void loop()
{
  // Messwerte BME
  bme_time_start = millis();
  if (bme_time_start > bme_time_actual + bme_interval)
  {
    bme_time_actual = millis();
    measure_bme(); 
  }

  // Messwerte Licht/UV
  li_time_start = millis();
  if (li_time_start > li_time_actual + li_interval)
  {
    li_time_actual = millis();
    measure_light();
  }

  // Messwerte PM / Feinstaub
  pm_time_start = millis();
  if (pm_time_start > pm_time_actual + pm_interval)
  {
    pm_time_actual = millis();
    measure_pm();
  }

  // Messwerte CO2
  co2_time_start = millis();
  if (co2_time_start > co2_time_actual + co2_interval)
  {
    co2_time_actual = millis();
    measure_co2();
  }
   
  // Daten an serial
  if (DEBUG_DATA) {
    serial_debug();
  }

  // Daten an OpenSenseMap
  osm_time_start = millis();
    if (osm_time_start > osm_time_actual + osm_interval) 
    {
      osm_time_actual = millis();
      DEBUG();
      DEBUG("Data to oSM...");
      senddataOSM();      // Daten Block openSenseMap  
   }
 
  // Daten an TheThingsNetwork TTN - execute scheduled jobs and events
  os_runloop_once();
  
}

#4

Da du schreibst, dass der erste Push noch ausgeführt wird und danach sich die Box aufhängt wird es an der Funktion do_send(&sendjob) liegen, die das Übertragen über LoRa initialisiert.

Hast du mal versucht den gesamten Code schrittweise aufzubauen? Und erst nach und nach alle Funktionen zu implementieren?


#5

Hallo @mario,

auf diesem Weg hat sich der Code mit der Zeit nach und nach entwickelt und wurde dabei immer auch ausgeführt.

  1. Einbindung der Sensoren, Auslesen der Daten, Ausgabe auf Serial.
  2. Wifi-Bee und oSM, wobei hierbei schon von Anfang an https nicht klappt Sketch von oSM mit WiFi, Daten werden nur beim ersten Mal gesendet
  3. Lora-Bee und Lora Verbindung
  4. Telegram Bot, auch hier kein https Telegram Bot - kein Connect
  5. Pushover Script, im Setup geht eine Meldung raus und dann geht es nicht weiter, auch nicht vor der Lora Initialisierung. Wenn das Skript bei einem Event eingebunden wird, dann geht keine Meldung raus, Sensebox läuft normal weiter.

Irgendwie dreht sich das Thema durchweg um Wifi, https bei osm, Telegram und Test-Sketch oder pushover-script. Hatte schon gefragt, ob etwas mit dem Wifi-Bee nicht stimmt…?

Danke.