Group 11 : IoT-Based Urban Gardening 2024

// Seeeduino LoRaWAN ------------------------------------------------------------
#define PIN_GROVE_POWER 38
#define SerialUSB Serial
 
// LoRaWAN -----------------------------------------------------------------------
#include <LoRaWan.h>
 
// Put your LoRa keys here
#define DevEUI "002A862DA290C679"
#define AppEUI "70B3D57ED002F952"
#define AppKey "1741A4E69973C2AE31754F88DFEA33AC"
 
// CayenneLPP --------------------------------------------------------------------
#include <CayenneLPP.h>  // Include Cayenne Library
CayenneLPP lpp(51);      // Define the buffer size: Keep as small as possible
 
// Sensor Libraries
// sunlight
#include "SI114X.h" 
// temperature
#include "seeed_bme680.h"
#define BME_SCK 13
#define BME_MISO 12
#define BME_MOSI 11
#define BME_CS 10

// Sensor instances
SI114X SI1145 = SI114X();
#define IIC_ADDR  uint8_t(0x76)
Seeed_BME680 bme680(IIC_ADDR);


// SETUP -------------------------------------------------------------------------
// vars
char buffer[256];
void setup(void)
{
  // Setup Serial connection
  delay(5000);
  Serial.begin(115200);
 
  // Powerup Seeeduino LoRaWAN Grove connectors
  pinMode(PIN_GROVE_POWER, OUTPUT);
  digitalWrite(PIN_GROVE_POWER, 1);
 
  // Config LoRaWAN
  lora.init();
 
  memset(buffer, 0, 256);
  lora.getVersion(buffer, 256, 1);
  if (Serial) {
    Serial.print(buffer);
  }
 
  memset(buffer, 0, 256);
  lora.getId(buffer, 256, 1);
  if (Serial) {
    Serial.print(buffer);
  }
 
  // void setId(char *DevAddr, char *DevEUI, char *AppEUI);
  // replace the xxxxxx and the yyyyyy below with the DevEUI and the
  // AppEUI obtained from your registered sensor node and application
  // in The Things Network (TTN). The numbers are hexadecimal strings
  // without any leading prefix like "0x" and must have exactly the
  // same number of characters as given below.
  // lora.setId(NULL, "xxxxxxxxxxxxxxxx", "yyyyyyyyyyyyyyyy");
  lora.setId(NULL, DevEUI, AppEUI);
 
  // setKey(char *NwkSKey, char *AppSKey, char *AppKey);
  // replace the zzzzzz below with the AppKey obtained from your registered
  // application in The Things Network (TTN). The numbers are hexadecimal
  // strings without any leading prefix like "0x" and must have exactly
  // the same number of characters as given below.
  // lora.setKey(NULL, NULL, "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz");
  lora.setKey(NULL, NULL, AppKey);
 
  lora.setDeciveMode(LWOTAA);
  lora.setDataRate(DR0, EU868);      // DR5 = SF7, DR0 = SF 12
  lora.setAdaptiveDataRate(true);
 
  lora.setChannel(0, 868.1);
  lora.setChannel(1, 868.3);
  lora.setChannel(2, 868.5);
  lora.setChannel(3, 867.1);
  lora.setChannel(4, 867.3);
  lora.setChannel(5, 867.5);
  lora.setChannel(6, 867.7);
  lora.setChannel(7, 867.9);
 
  lora.setDutyCycle(false);
  lora.setJoinDutyCycle(false);
 
  lora.setPower(14);
  lora.setPort(33);
 
  unsigned int nretries;
  nretries = 0;
  while (!lora.setOTAAJoin(JOIN, 20)) {
    nretries++;
    if (Serial) {
      Serial.println((String)"Join failed, retry: " + nretries);
    }
  }
  Serial.println("Join successful!");
}
 
// LOOP --------------------------------------------------------------------
unsigned int nloops = 0;
void loop(void) {
  nloops++;
  if (Serial) {
    Serial.println((String)"Loop " + nloops + "...");
  }
 
  bool result = false;
 
  // Read sunlight sensor data
  float visible = SI1145.ReadVisible();
  float IR = SI1145.ReadIR();
  float UV = SI1145.ReadUV();
  float uvIndex = UV / 100.0;  // UV index

  // Read environmental sensor data
  bme680.init();
  bme680.read_sensor_data();
  float temperature = bme680.read_temperature();  // Celsius
  float humidity = bme680.read_humidity();        // %
  float pressure = bme680.read_pressure();        // hPa
  float gas = bme680.read_gas() / 1000.0; // kOhms
  float moisture = analogRead(A0); 

  // Reset CayenneLPP buffer and add sensor data
  lpp.reset();
  lpp.addTemperature(1, temperature);
  lpp.addRelativeHumidity(2, humidity);
  lpp.addBarometricPressure(3, pressure);
  lpp.addAnalogInput(4, gas);  // Assuming gas resistance as analog input
  lpp.addLuminosity(5, visible);
  lpp.addLuminosity(6, IR);
  lpp.addAnalogInput(7, uvIndex);  // UV index as analog input
  lpp.addAnalogInput(8, moisture);
 
  // Transfer LoRa package
  result = lora.transferPacket(lpp.getBuffer(), lpp.getSize(), 5);                  // sends the Cayenne encoded data packet (n bytes) with a default timeout of 5 secs
  // result = lora.transferPacketWithConfirmed(lpp.getBuffer(), lpp.getSize(), 5);  // sends the Cayenne encoded data packet (n bytes) with a default timeout of 5 secs, using confirmed LoRa package
 
  if (result) {
    short length;
    short rssi;
 
    // Receive LoRaWAN package (LoraWAN Class A)
    char rx[256];
    length = lora.receivePacket(rx, 256, &rssi);
 
    // Check, if a package was received
    if (length)
    {
      if (Serial) {
        Serial.print("Length is: ");
        Serial.println(length);
        Serial.print("RSSI is: ");
        Serial.println(rssi);
        Serial.print("Data is: ");
 
        // Print received data as HEX
        for (unsigned char i = 0; i < length; i ++)
        {
          Serial.print("0x");
          Serial.print(rx[i], HEX);
          Serial.print(" ");
        }
 
        // Convert received package to int
        int rx_data_asInteger = atoi(rx);
 
        Serial.println();
        Serial.println("Received data: " + String(rx_data_asInteger));
      }
    }
  }
   
  if (Serial) {
    Serial.println((String)"Loop " + nloops + "...done!\n");
  }
  delay(60000);
 
}

import requests
import json
import time

# FROST server URL
FROST_SERVER_URL = 'https://gi3.gis.lrg.tum.de/frost/v1.1'

# Function to retrieve data from a specific Datastream
def get_latest_observations(datastream_ids, interval=5):
    while True:
        observations_by_datastream = {}
        for datastream_id in datastream_ids:
            url = f"{FROST_SERVER_URL}/Datastreams({datastream_id})/Observations?$orderby=phenomenonTime%20desc&$top=1"
            response = requests.get(url)
            if response.status_code == 200:
                data = response.json()
                observations_by_datastream[datastream_id] = data["value"][0]["result"]
            else:
                print(f"Failed to retrieve data: {response.status_code} {response.reason}")
        #result_value = observations_by_datastream['result']
        yield 'data: {}\n\n'.format(json.dumps(observations_by_datastream))
        time.sleep(interval) 

import requests
import time
import json

def get_weather(api_key, city_name, interval=60):
    while True:
        weather_values = {}
        base_url = 'http://api.openweathermap.org/data/2.5/weather?'
        complete_url = f'{base_url}q={city_name}&appid={api_key}&units=metric'
        backoff_time = interval
        
        while True:
            response = requests.get(complete_url)
            if response.status_code == 200:
                data = response.json()
                main = data['main']
                wind = data['wind']
                weather = data['weather'][0]
                weather_values['Temperature'] = main['temp']
                weather_values['Wind Speed'] = wind['speed']
                weather_values['Humidity'] = main['humidity']
                weather_values['Weather description'] = weather['description']
                yield 'data: {}\n\n'.format(json.dumps(weather_values))
                break
            elif response.status_code == 429:
                print(f"Failed to retrieve data: {response.status_code}. Retrying in {backoff_time} seconds.")
                time.sleep(backoff_time)
                backoff_time *= 2  # Exponential backoff
            else:
                print(f"Failed to retrieve data: {response.status_code}")
                break
        
        time.sleep(interval)


def main():
    # Replace 'your_api_key' with your actual OpenWeatherMap API key
    api_key = '4890013cad9b0ee94bf0edd0d861d569'
    city_name = 'Munich'
    
    while True:
        get_weather(api_key, city_name)
        time.sleep(10)  # Wait for 10 seconds before the next update

if __name__ == "__main__":
    main()

from flask import Flask, render_template, request, Response, send_from_directory
from data_retrieving_frost import get_latest_observations
from data_retrieving_wf import get_weather

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/dashboard')
def dashboard():
    return render_template('dashboard.html')

@app.route('/css/<path:path>')
def send_css(path):
    return send_from_directory('static/css', path)

@app.route('/js/<path:path>')
def send_js(path):
    return send_from_directory('static/js', path)

@app.route('/frost')
def frost():
    datastream_ids = [1059, 1062, 1064, 1065, 1066, 1067, 1068, 1069]
    return Response(get_latest_observations(datastream_ids, interval=5), mimetype='text/event-stream')

@app.route('/weatherforecast')
def weatherforecast():
    api_key = '4890013cad9b0ee94bf0edd0d861d569'
    city_name = 'Munich'
    return Response(get_weather(api_key, city_name, interval=60), mimetype='text/event-stream')
    
if __name__ == '__main__':
    app.run(debug=True, port=5500)