wetterstation.sub

#!/bin/bash
### Subroutinen V1.3.0 --------------------------------------------------------


 #Bezeichnung der Datenpunkte
  DP_TEMP_INNEN=${PRE_DP}.Innentemperatur
  DP_TEMP_AUSSEN=${PRE_DP}.Aussentemperatur
  DP_TAUPUNKT=${PRE_DP}.Taupunkt
  DP_CHILL=${PRE_DP}.Chillfaktor
  DP_FEUCHTE_INNEN=${PRE_DP}.Innenfeuchtigkeit
  DP_FEUCHTE_AUSSEN=${PRE_DP}.Aussenfeuchtigkeit
  DP_WIND=${PRE_DP}.Wind
  DP_WIND_MAX=${PRE_DP}.Wind_max
  DP_WIND_DIR=${PRE_DP}.Windrichtung
  DP_WIND_DIR_TXT=${PRE_DP}.Windrichtung_Text
  DP_DRUCK_ABS=${PRE_DP}.Druck_absolut
  DP_DRUCK_REL=${PRE_DP}.Druck_relativ
  DP_REGENRATE=${PRE_DP}.Regenrate
  DP_REGENSTATUS=${PRE_DP}.Regenstatus
  DP_REGEN_TAG=${PRE_DP}.Regen_Tag
  DP_REGEN_WOCHE=${PRE_DP}.Regen_Woche
  DP_REGEN_MONAT=${PRE_DP}.Regen_Monat
  DP_REGEN_JAHR=${PRE_DP}.Regen_Jahr
  DP_REGEN_JAHR_KUM=${PRE_DP}.Regen_Jahr_kumuliert
  DP_SONNE=${PRE_DP}.Sonnenstrahlung
  DP_UV_INDEX=${PRE_DP}.UV_Index
  DP_UV_BELASTUNG=${PRE_DP}.UV_Belastung
  DP_ZEITSTEMPEL=${PRE_DP}.Zeitstempel
  DP_WETTER_TREND=${PRE_DP}.Wetter_Trend
  DP_WETTER_AKTUELL=${PRE_DP}.Wetter_aktuell
  DP_DRUCK_TENDENZ=${PRE_DP}.Druck_Tendenz
  DP_KOMFEHLER=${PRE_DP}._Kommunikationsfehler
  DP_WETTERDATA=${PRE_DP}.tempData.Wetterdaten
  DP_SONNENSCHEIN_SAVE=${PRE_DP}.tempData.Sonnenschein
  DP_SOLAR_SAVE=${PRE_DP}.tempData.Solarenergie
  DP_FW_UPGRADE=${PRE_DP}.Info.FW_Upgrade
  DP_FW_VERSION=${PRE_DP}.Info.FW_Version
  DP_SONNENSCHEIN_VORTAG=${PRE_DP}.Info.Sonnenschein_VorTag
  DP_SONNENSCHEIN_TAG=${PRE_DP}.Info.Sonnenschein_Tag
  DP_SONNENSCHEIN_WOCHE=${PRE_DP}.Info.Sonnenschein_Woche
  DP_SONNENSCHEIN_MONAT=${PRE_DP}.Info.Sonnenschein_Monat
  DP_SONNENSCHEIN_JAHR=${PRE_DP}.Info.Sonnenschein_Jahr
  DP_SONNENSCHEIN_TAG_TEXT=${PRE_DP}.Info.Sonnenschein_Tag_Text
  DP_SONNENSCHEIN_WOCHE_TEXT=${PRE_DP}.Info.Sonnenschein_Woche_Text
  DP_SONNENSCHEIN_MONAT_TEXT=${PRE_DP}.Info.Sonnenschein_Monat_Text
  DP_SONNENSCHEIN_JAHR_TEXT=${PRE_DP}.Info.Sonnenschein_Jahr_Text
  DP_SONNENSCHEIN_VORJAHR=${PRE_DP}.Info.Sonnenschein_VorJahr
  DP_REGENMENGE_VORJAHR=${PRE_DP}.Info.Regenmenge_VorJahr
  DP_SOLARENERGIE_VORTAG=${PRE_DP}.Info.Solarenergie_VorTag
  DP_SOLARENERGIE_TAG=${PRE_DP}.Info.Solarenergie_Tag
  DP_SOLARENERGIE_WOCHE=${PRE_DP}.Info.Solarenergie_Woche
  DP_SOLARENERGIE_MONAT=${PRE_DP}.Info.Solarenergie_Monat
  DP_SOLARENERGIE_JAHR=${PRE_DP}.Info.Solarenergie_Jahr
  DP_SOLARENERGIE_VORJAHR=${PRE_DP}.Info.Solarenergie_VorJahr
  DP_LETZTER_REGEN=${PRE_DP}.Info.Letzter_Regen
  DP_LETZTE_REGENMENGE=${PRE_DP}.Info.Letzte_Regenmenge


###  Ende Usereinstellungen


###-------------------------------------------------------------------------###
###  Subroutinen - KEINE ÄNDERUNGEN NÖTIG !                                 ###
###-------------------------------------------------------------------------###


###  Farbdefinition
      GR='\e[1;32m'
      GE='\e[1;33m'
      WE='\e[1;37m'
      BL='\e[1;36m'
      RE='\e[1;31m'


###  Debugging
debuging() {
  #Messwerteblock
   echo -e "\n\n${WE}Messwerteblock: $GR${MESSWERTERAW[*]}$WE"

  #Datenfelder ausgeben
   echo -e "\n\nTemperatur Innen\t: $GR${MESSWERTE[0]}$WE °C"
   echo -e "Temperatur Aussen\t: $GR${MESSWERTE[1]}$WE °C"
   echo -e "Taupunkt\t\t: $GR${MESSWERTE[2]}$WE °C"
   echo -e "Chill-Faktor\t\t: $GR${MESSWERTE[3]}$WE °C"
   echo -e "Luftfeuchte Innen\t: $GR${MESSWERTE[4]}$WE %"
   echo -e "Luftfeuchte Aussen\t: $GR${MESSWERTE[5]}$WE %"
   echo -e "Windgeschwindkeit\t: $GR${MESSWERTE[6]}$WE km/h"
   echo -e "max. Windgeschwindkeit\t: $GR${MESSWERTE[7]}$WE km/h"
   echo -e "Windrichtung\t\t: $GR${MESSWERTE[8]}$WE °"
   echo -e "Windrichtung\t\t: $GR${WINDRICHTUNG}$WE"
   echo -e "Luftdruck absolut\t: $GR${MESSWERTE[9]}$WE hPa"
   echo -e "Luftdruck relativ\t: $GR${MESSWERTE[10]}$WE hPa"
   echo -e "Regenrate\t\t: $GR${MESSWERTE[11]}$WE mm/h"
   echo -e "Regenstatus\t\t: $GR${REGENSTATUS}$WE"
   echo -e "Regen Tag\t\t: $GR${MESSWERTE[12]}$WE mm"
   echo -e "Regen Woche\t\t: $GR${MESSWERTE[13]}$WE mm"
   echo -e "Regen Monat\t\t: $GR${MESSWERTE[14]}$WE mm"
   echo -e "Regen Jahr\t\t: $GR${MESSWERTE[15]}$WE mm"
   echo -e "Sonnenstrahlung\t\t: $GR${MESSWERTE[16]}$WE W/m²"
   echo -e "UV-Index\t\t: $GR${MESSWERTE[17]}$WE"
   echo -e "Zeitstempel\t\t: $GR${MESSWERTE[18]}$WE"
   echo -e "Firmware\t\t: $GR${MESSWERTE[19]}$WE"

   echo -e "\n\nDatenstring für ioBroker:\n$GR$IOB_DATA$WE\n"
   if [ "$show_pwid" = "true" ]; then
      DAT=$DATA
    else
      DAT=$(echo $DATA| sed -e 's/PASSWORD=.*[^&]*&indoort/PASSWORD=xxxxxx\&indoort/; s/\?ID=.*[^&]*&PASS/\?ID=xxxxxx\&PASS/')
   fi
   echo -e "\nDATA von Wetterstation:\n$GR${DAT}$WE\n"

   echo -e "\nDebug VAR:"
   echo -e "Installationsverzeichnis: $GE$DIR$WE"
   echo -e "IPP: $GE${IPP}$WE\tWS_PORT: $GE${WS_PORT}$WE\t\tWS_POLL: $GE${WS_POLL}$WE\t\tPRE_DP: $GE${PRE_DP}$WE"
   echo -e "Script-Version: $GE$SH_VER$WE\tConfig-Version: $GE${CONF_V}$WE\tSub-Version: $GE${SUBVER}$WE"

   if [ ! -z "$KOMFEHLER" ]; then echo -e "\n${RE}Kommunikationsfehler! Stimmt die WS_ID in der Konfiguration mit der der WS View-App überein?$WE\n"; fi
  #Shell-Skript mit Fehler beenden
    exit 1
}


### ioB-Daten senden
iob_send() {
   #build Data-String
    IOB_DATA=$(cat <<-EOD
	${DP_TEMP_INNEN}=${MESSWERTE[0]}
	&${DP_TEMP_AUSSEN}=${MESSWERTE[1]}
	&${DP_TAUPUNKT}=${MESSWERTE[2]}
	&${DP_CHILL}=${MESSWERTE[3]}
	&${DP_FEUCHTE_INNEN}=${MESSWERTE[4]}
	&${DP_FEUCHTE_AUSSEN}=${MESSWERTE[5]}
	&${DP_WIND}=${MESSWERTE[6]}
	&${DP_WIND_MAX}=${MESSWERTE[7]}
	&${DP_WIND_DIR}=${MESSWERTE[8]}
	&${DP_WIND_DIR_TXT}=${WINDRICHTUNG}
	&${DP_DRUCK_ABS}=${MESSWERTE[9]}
	&${DP_DRUCK_REL}=${MESSWERTE[10]}
	&${DP_REGENRATE}=${MESSWERTE[11]}
	&${DP_REGEN_TAG}=${MESSWERTE[12]}
	&${DP_REGEN_WOCHE}=${MESSWERTE[13]}
	&${DP_REGEN_MONAT}=${MESSWERTE[14]}
	&${DP_REGEN_JAHR}=${MESSWERTE[15]}
	&${DP_SONNE}=${MESSWERTE[16]}
	&${DP_UV_INDEX}=${MESSWERTE[17]}
	EOD
     )

   #Leerzeichen entfernen + Zeitstempel/Regenstatus/UV-Belastung wg. Leerzeichen erst hier anhängen
    IOB_DATA=$(echo $IOB_DATA|tr -d " ")
    IOB_DATA=${IOB_DATA}\&${DP_REGENSTATUS}=${REGENSTATUS}\&${DP_UV_BELASTUNG}=${UV_BELASTUNG}\&${DP_ZEITSTEMPEL}=${MESSWERTE[18]}


   #Daten an den ioB schicken
    if [ $debug == "true" ]; then
	curl --data "$IOB_DATA&prettyPrint" http://${IPP}/setBulk
      else
	curl --data "$IOB_DATA" http://${IPP}/setBulk >/dev/null 2>&1
    fi
}



### Daten holen und Integritätscheck
get_DATA() {
  #auf Daten der Wetterstation warten
   DATA=$(timeout ${WARTE} nc -lvw 1 -p ${WS_PORT}|sed -n '1 p')
   STRLEN=$(echo -n $DATA | wc -m)

  #haben wir eine Jahresregenmenge?
   if [[ ! "$DATA" =~ "yearlyrainin" ]]; then DATA=$(echo $DATA| sed -e 's/solarradiation/yearlyrainin=0\&solarradiation/' ); fi
  #check auf Datenintigrität
   if [ "$STRLEN" -gt "400" ] && [[ "$DATA" =~ "/weatherstation/updateweatherstation.php?ID=${WS_ID}" ]]; then return 0; else return 1; fi
}



### Datenpaket der Wetterstation anzeigen
ws_data() {
   echo -e "\n\nWarte maximal ${WARTE} Sekunden auf Datenpaket der Wetterstation...\n" && timeout ${WARTE} nc -lvw 1 -p ${WS_PORT} | sed -n '1 p'
}



### Datenkonvertierungen
convertFtoC() {
	MESSWERTE[$i]=`echo "scale=2;(${MESSWERTE[$i]}-32)*5/9" | bc -l`
}

convertMPHtoKMH() {
	MESSWERTE[$i]=`echo "scale=2;(${MESSWERTE[$i]}*16094/10000)" | bc -l`
}

convertLuftdruck() {
	MESSWERTE[$i]=`echo "scale=2;${MESSWERTE[$i]}*33864/1000" | bc -l`
}

convertInchtoMM() {
	MESSWERTE[$i]=`echo "scale=1;${MESSWERTE[$i]}*254/10" | bc -l`
	#Regenstatus bestimmen (#11)
	if [ "$i" -eq "11" ]; then
	 REGEN=$(round ${MESSWERTE[11]} 0)
	 if [ "$REGEN" -ge "10" ]; then REGENSTATUS="Starkregen"; fi
	 if [ "$REGEN" -lt "10" ]; then REGENSTATUS="starker Regen"; fi
	 if [ "$REGEN" -lt "4" ]; then REGENSTATUS="mäßiger Regen"; fi
	 if [ "$REGEN" -eq "1" ]; then REGENSTATUS="leichter Regen"; fi
	 if [ "$REGEN" -eq "0" ]; then REGENSTATUS="kein Regen"; fi
	fi
	#letztes Regenereignis + letzte Regenmenge
	if [ "$REGEN" -gt "0" ] && [ "$i" -eq "12" ]; then
	 AKT_TIMESTAMP=`date +%s`
	 if [ $LAST_RAIN == "DATUM" ]; then LASTRAINMSG=`date "+%d.%m.%Y %H:%M"`; fi
	 if [ $LAST_RAIN == "UNIX" ]; then LASTRAINMSG=${AKT_TIMESTAMP}; fi
	 curl --data "${DP_LETZTER_REGEN}=${LASTRAINMSG}&${DP_LETZTE_REGENMENGE}=${MESSWERTE[12]}" http://${IPP}/setBulk >/dev/null 2>&1
	fi
	if [ $LAST_RAIN == "DIFF" ]; then
	   LC=$(curl -s http://${IPP}/get/${DP_REGENRATE}?prettyPrint | grep '"lc":' | tr -d [:alpha:]:\ ,\")
	   LC=`echo "scale=0;${LC}/1000" | bc -l`
	   TS_AKT=$(date +%s)
	   TS_DIFF=`echo "${TS_AKT}-${LC}" | bc`
           TAGE=$(echo "$(($TS_DIFF /86400))")
	   case $TAGE in
		0)  STUNDEN=$(echo "$(($TS_DIFF /3600))")
		    if [ "$STUNDEN" -eq "1" ]; then
			LASTRAINMSG="vor einer Stunde"
		    else
		        LASTRAINMSG="vor $STUNDEN Stunden"
		    fi
		    if [ "$STUNDEN" -eq "0" ]; then LASTRAINMSG="gerade eben"; fi ;;
		1)  LASTRAINMSG="vor einem Tag" ;;
		*)  LASTRAINMSG="vor $TAGE Tagen"
	   esac
	   curl --data "${DP_LETZTER_REGEN}=${LASTRAINMSG}" http://${IPP}/setBulk >/dev/null 2>&1
	fi

}

convertTime() {
	MESSWERTE[$i]=$(echo ${MESSWERTE[$i]}|sed -e 's/%20/ /')
	MESSWERTE[$i]=$(date --date="${MESSWERTE[$i]} UTC" +'%d.%m.%Y %H:%M:%S')
	#MESSWERTE[$i]=$(echo ${MESSWERTE[$i]}|awk -F'-|%20' '{printf "%02s.%02s.%s %s", $3, $2, $1, $4}')
}



###Jahresregenmenge
rain() {
	   LC=$(curl -s http://${IPP}/get/${DP_REGEN_JAHR_KUM}?prettyPrint | grep '"lc":' | tr -d [:alpha:]:\ ,\")
	   LC=`echo "scale=0;${LC}/1000" | bc -l`
	   TS_AKT=$(date +%s)
	   TS_DIFF=`echo "${TS_AKT}-${LC}-3600" | bc` #mind. 1 Stunde Differenz

	  if [ ${TS_DIFF} -ge "0" ]; then
	   REGENMENGE=$(curl -s http://${IPP}/getPlainValue/${DP_REGEN_JAHR_KUM})
	   REGENMENGE=$(echo "scale=2;$REGENMENGE+${MESSWERTE[12]}" | bc -l)
	   curl http://${IPP}/set/${DP_REGEN_JAHR_KUM}?value=${REGENMENGE} >/dev/null 2>&1
	  fi
}



###Windrichtung als Text
winddir() {
   WINDRICHTUNG=${WINDDIRS[$(round ${MESSWERTE[8]}/22.5 0)]}
}



###Wetterprognose
wetterprognose() {
	let TIMER_SET=$(date +%s)+90
	LUFTDRUCK=$(round ${MESSWERTE[10]} 0)

	#Array bilden
	DRUCKWERTE=(${DRUCKWERTE[@]:1})
	DRUCKWERTE[11]=$LUFTDRUCK


	#Tendenz berechnen
	if [ "${DRUCKWERTE[0]}" -gt "20" ]; then
	 let PNOW=($LUFTDRUCK-${DRUCKWERTE[0]})*10
	 if [ "$PNOW" -le "-80" ]; then WETTER_TREND="Sturm mit Hagel"; fi
	 if [ "$PNOW" -le "-50" ] && [ "$PNOW" -gt "-80" ]; then WETTER_TREND="Regen/Unwetter"; fi
	 if [ "$PNOW" -le "-30" ] && [ "$PNOW" -gt "-50" ]; then WETTER_TREND="regnerisch"; fi
	 if [ "$PNOW" -le "-5" ] && [ "$PNOW" -gt "-30" ]; then WETTER_TREND="baldiger Regen"; fi
	 if [ "$PNOW" -le "5" ] && [ "$PNOW" -gt "-5" ]; then WETTER_TREND="gleichbleibend"; fi
	 if [ "$PNOW" -le "30" ] && [ "$PNOW" -ge "5" ]; then WETTER_TREND="lange schön"; fi
	 if [ "$PNOW" -le "50" ] && [ "$PNOW" -ge "30" ]; then WETTER_TREND="schön & labil"; fi
	 if [ "$PNOW" -gt "50" ]; then WETTER_TREND="Sturmwarnung"; fi
	 PNOW=`echo "scale=2;$PNOW/10" | bc -l`
	fi

	#Wetter erfassen und bestimmen
	 if [ "$LUFTDRUCK" -le "980" ]; then WETTER_AKTUELL="Stürmisch, Regen"; fi
	 if [ "$LUFTDRUCK" -gt "980" ] && [ "$LUFTDRUCK" -le "1000" ]; then WETTER_AKTUELL="Regnerisch"; fi
	 if [ "$LUFTDRUCK" -gt "1000" ] && [ "$LUFTDRUCK" -le "1020" ]; then WETTER_AKTUELL="Wechselhaft"; fi
	 if [ "$LUFTDRUCK" -gt "1020" ] && [ "$LUFTDRUCK" -le "1040" ]; then WETTER_AKTUELL="Sonnig"; fi
	 if [ "$LUFTDRUCK" -gt "1040" ]; then WETTER_AKTUELL="Trocken, Gewitter"; fi


	#falls Initialisierung
	if [[ "$WETTER_TREND" =~ "Minuten" ]]; then
	 let RESTZEIT=15*${DRUCKWERTE[0]}
	 WETTER_TREND="dauert noch ${RESTZEIT} Minuten"
	fi

	#sicherstellen dass nur Zahlen im 2. Wert vorhanden sind
	#DRUCKWERTE[1]=$(echo ${DRUCKWERTE[1]} | grep -o '[0-9]*')

	#build Data-String
	IOB_WDATA=$(cat <<-EOD
	${DP_WETTER_TREND}=${WETTER_TREND}
	&${DP_DRUCK_TENDENZ}=${PNOW}
	&${DP_WETTER_AKTUELL}=${WETTER_AKTUELL}
	&${DP_WETTERDATA}=${DRUCKWERTE[*]}
	EOD
	)

    curl --data "${IOB_WDATA}" http://${IPP}/setBulk >/dev/null 2>&1

}



###Check auf Firmwareupgrade
firmware_check() {
	#Version auf GitHub holen
	FW_VER=$(curl https://raw.githubusercontent.com/SBorg2014/WLAN-Wetterstation/master/firmware.version)
	FW_AKT=${MESSWERTE[19]}
	if [ "$FW_VER" != "$FW_AKT" ]; then
	  curl "http://${IPP}/set/${DP_FW_UPGRADE}?value=true" >/dev/null 2>&1
	 else
	  curl "http://${IPP}/set/${DP_FW_UPGRADE}?value=false" >/dev/null 2>&1
	fi
	curl "http://${IPP}/set/${DP_FW_VERSION}?value=${FW_AKT}" >/dev/null 2>&1
}



###Sonnenscheindauer (>=120W/m²) / Solarenergie
sonnenpuls() {
    SONNEN_STRAHLUNG=$(round ${MESSWERTE[16]} 0)
    if [ "$SONNEN_STRAHLUNG" -ge "120" ] || [ ! -z "$MIDNIGHTRUN" ]; then
	AKT_TIMESTAMP=`date +%s`
	let SONNENPULS_DIFF=${AKT_TIMESTAMP}-${TIMER_START}
	if [ "$SONNENPULS_DIFF" -lt "300" ]; then
	 let SONNENSCHEIN_TAG+="$SONNENPULS_DIFF"
	 let SONNENSCHEIN_WO+="$SONNENPULS_DIFF"
	 let SONNENSCHEIN_MO+="$SONNENPULS_DIFF"
	 let SONNENSCHEIN_JAHR+="$SONNENPULS_DIFF"
	fi
	curl --data "${DP_SONNENSCHEIN_SAVE}=${SONNENSCHEIN_TAG} ${SONNENSCHEIN_WO} ${SONNENSCHEIN_MO} ${SONNENSCHEIN_JAHR}" http://${IPP}/setBulk >/dev/null 2>&1
	timestr ${SONNENSCHEIN_TAG} SONNENDAUER_STR_TAG
	timestr ${SONNENSCHEIN_WO} SONNENDAUER_STR_WO
	timestr ${SONNENSCHEIN_MO} SONNENDAUER_STR_MO
	timestr ${SONNENSCHEIN_JAHR} SONNENDAUER_STR_JAHR

	#build + send Data-String
	IOB_SDATA=$(cat <<-EOD
	${DP_SONNENSCHEIN_TAG_TEXT}=${SONNENDAUER_STR_TAG}
	&${DP_SONNENSCHEIN_WOCHE_TEXT}=${SONNENDAUER_STR_WO}
	&${DP_SONNENSCHEIN_MONAT_TEXT}=${SONNENDAUER_STR_MO}
	&${DP_SONNENSCHEIN_JAHR_TEXT}=${SONNENDAUER_STR_JAHR}
	&${DP_SONNENSCHEIN_TAG}=${SONNENSCHEIN_TAG}
	&${DP_SONNENSCHEIN_WOCHE}=${SONNENSCHEIN_WO}
	&${DP_SONNENSCHEIN_MONAT}=${SONNENSCHEIN_MO}
	&${DP_SONNENSCHEIN_JAHR}=${SONNENSCHEIN_JAHR}
	EOD
	)
	if [ -z $MIDNIGHTRUN ]; then TIMER_START=`date +%s`; fi
	curl --data "${IOB_SDATA}" http://${IPP}/setBulk >/dev/null 2>&1
    fi

	###Solarenergie
    if [ "$SONNEN_STRAHLUNG" -gt "0" ] || [ ! -z "$MIDNIGHTRUN" ]; then
	#Array bilden
	SOLARENERGIE=(${SOLARENERGIE[@]:1})
	SOLARENERGIE[1]=$SONNEN_STRAHLUNG

	#Mittelwert berechnen
	SOL_TMP=$(echo "scale=2;(${SOLARENERGIE[0]}+${SOLARENERGIE[1]})/2" | bc -l)

	#Leistung berechnen
	SOL_TMP=$(echo "scale=3;${SOL_TMP}/(3600/${WS_POLL})" | bc -l)
	SOLARENERGIE_TAG=`echo "scale=3;${SOLARENERGIE_TAG}+${SOL_TMP}" | bc -l`
	SOLAR_WOCHE=`echo "scale=5;(${SOLAR_WOCHE}+${SOL_TMP})" | bc -l`
	SOLARENERGIE_WOCHE=`echo "scale=3;${SOLAR_WOCHE}/1000" | bc -l` #Umrechnung in kWh
	SOLAR_MONAT=`echo "scale=5;(${SOLAR_MONAT}+${SOL_TMP})" | bc -l`
	SOLARENERGIE_MONAT=`echo "scale=3;${SOLAR_MONAT}/1000" | bc -l` #Umrechnung in kWh
	SOLAR_JAHR=`echo "scale=5;(${SOLAR_JAHR}+${SOL_TMP})" | bc -l`
	SOLARENERGIE_JAHR=`echo "scale=3;${SOLAR_JAHR}/1000" | bc -l`   #Umrechnung in kWh

	#Daten für ioB fertig machen
	IOB_SOLDATA=$(cat <<-EOD
	${DP_SOLARENERGIE_TAG}=${SOLARENERGIE_TAG}
	&${DP_SOLARENERGIE_WOCHE}=${SOLARENERGIE_WOCHE}
	&${DP_SOLARENERGIE_MONAT}=${SOLARENERGIE_MONAT}
	&${DP_SOLARENERGIE_JAHR}=${SOLARENERGIE_JAHR}
	&${DP_SOLAR_SAVE}=${SOLARENERGIE_TAG} ${SOLAR_WOCHE} ${SOLAR_MONAT} ${SOLAR_JAHR}
	EOD
	)

	curl --data "${IOB_SOLDATA}" http://${IPP}/setBulk >/dev/null 2>&1
    fi

}



###UV-Belastung
uv_belastung() {
	UV_TMP=$(round ${MESSWERTE[17]} 0)
	case ${UV_TMP} in
	   0)      UV_BELASTUNG="keine" ;;
	   1|2)    UV_BELASTUNG="gering" ;;
	   3|4|5)  UV_BELASTUNG="mittel" ;;
	   6|7)    UV_BELASTUNG="hoch" ;;
	   8|9|10) UV_BELASTUNG="sehr hoch" ;;
	   *)      UV_BELASTUNG="--"
	esac
	if [ "${UV_TMP}" -ge "11" ]; then UV_BELASTUNG="extrem hoch"; fi
}



###Hilfsfunktionen
timestr() {
	TAGE=$(echo "$(($1 /86400))")
	STUNDEN_KPL=$(echo "$(($1 /3600))")
	STUNDEN=$(echo "$(($1 % 86400 /3600))")
	MINUTEN=$(echo "$(($1 % 3600 /60))")
	SEKUNDEN=$(echo "$(($1 % 60))")

	if [ "$TAGE" -eq "1" ]; then TAG_TXT="Tag"; else TAG_TXT="Tage"; fi

	case ${SONNENSCHEIN_TXTFORMAT} in
	   0)   printf -v $2 "%d Std. %02d Min. %02d Sek." $STUNDEN_KPL $MINUTEN $SEKUNDEN ;;
	   1)   printf -v $2 "%d:%02d" $STUNDEN_KPL $MINUTEN ;;
	   2)   printf -v $2 "%d $TAG_TXT %d Std." $TAGE $STUNDEN ;;
	   3)   if [ "$TAGE" -eq "0" ]; then
	          printf -v $2 "%d Std, %d Min" $STUNDEN $MINUTEN
	         else
	          printf -v $2 "%d $TAG_TXT, %d Std, %d Min" $TAGE $STUNDEN $MINUTEN
	        fi ;;
	   *)   printf -v $2 "unbekanntes Format"
	esac
}

round() {
    bc -l <<END_BC
        define round(number,r_scale)
        {
            auto o_scale
            o_scale = scale
            scale = r_scale+1
            number += 5 / (10 ^ scale)
            scale = r_scale
            number /= 1
            scale = o_scale
            return number
        }
        round ($1,$2)
END_BC
}

reset_zaehler() {
	#VorZaehler aktualisieren
	curl http://${IPP}/set/${DP_SONNENSCHEIN_VORTAG}?value="${SONNENSCHEIN_TAG}" >/dev/null 2>&1
	curl http://${IPP}/set/${DP_SOLARENERGIE_VORTAG}?value="${SOLARENERGIE_TAG}" >/dev/null 2>&1

	#Tageszähler resetten
	SONNENSCHEIN_TAG=0
	SOLARENERGIE_TAG=0
	SOLARENERGIE[0]=0
	SOLARENERGIE[1]=0
	TIMER_START=0

	#Wochenzähler resetten (Sonntags um 0:00 Uhr)
	if [ `date +%u` -eq "7" ]; then
	   SONNENSCHEIN_WO=0
	   SOLAR_WOCHE=0
	fi

	#Monatszähler resetten
	if [ $(date -d "now + 1 day" +"%d") -eq "01" ]; then
	  SONNENSCHEIN_MO=0
	  SOLAR_MONAT=0
	  if [ `date +%m` -eq "12" ]; then
		#Jahreszähler resetten
		curl http://${IPP}/set/${DP_REGENMENGE_VORJAHR}?value="${REGENMENGE}" >/dev/null 2>&1
		curl http://${IPP}/set/${DP_SONNENSCHEIN_VORJAHR}?value="${SONNENSCHEIN_JAHR}" >/dev/null 2>&1
		curl http://${IPP}/set/${DP_SOLARENERGIE_VORJAHR}?value="${SOLAR_JAHR}" >/dev/null 2>&1
		REGENMENGE=0
		SONNENSCHEIN_JAHR=0
		SOLAR_JAHR=0
	  fi
	fi

	MIDNIGHTRUN=1; sonnenpuls

}

setup() {
  let "WARTE=WS_POLL*2+6"    #2x Poll + Zuschlag warten
  TIMER_SET=$(date +%s)      #Initial Set
  TIMER_START=0              #Reset Sonnenpuls
  #Anzeige bis Daten komplett
  WETTER_TREND="noch --- Minuten"

  declare -a MESSWERTE
  declare -a MESSWERTERAW
  SOLARENERGIE=(0 0)
  DRUCKWERTE=(12 11 10 9 8 7 6 5 4 3 2 1)
  WINDDIRS=(N NNO NO ONO O OSO SO SSO S SSW SW WSW W WNW NW NNW N)

 #Check ob Pollintervall größer 16 Sekunden
  if [ ${WS_POLL} -lt "16" ]; then WS_POLL=16; fi

 #falls reboot warten bis der ioB wieder läuft...
  while ! nc -v -z $(echo $IPP|sed -e 's/:/ /'); do sleep 30; done

 #Fehlermeldungen resetten
  curl "http://${IPP}/set/${DP_KOMFEHLER}?value=false&ack=true" >/dev/null 2>&1

 #Wetterdatenarray lesen
 DRUCKWERTE_TMP=$(curl -s http://${IPP}/getPlainValue/${DP_WETTERDATA}|sed -e 's/\"//g')

 if [ ${#DRUCKWERTE_TMP} -le "2" ]; then
   DRUCKWERTE_TMP=${DRUCKWERTE[*]}
   curl --data "${DP_WETTERDATA}=${DRUCKWERTE_TMP}" http://${IPP}/setBulk >/dev/null 2>&1
  else
   LC=$(curl -s http://${IPP}/get/${DP_WETTERDATA}?prettyPrint | grep '"lc":' | tr -d [:alpha:]:\ ,\")
   LC=`echo "scale=0;${LC}/1000" | bc -l`
   TS_AKT=$(date +%s)
   TS_DIFF=`echo "${TS_AKT}-${LC}-3600" | bc` #mind. 1 Stunde Differenz (dann >0)
   if [ "$TS_DIFF" -le "0" ]; then
     IFS=" "
     DRUCKWERTE=(${DRUCKWERTE_TMP[*]})
     if [ "${DRUCKWERTE[1]}" -gt "20" ]; then WETTER_TREND="dauert max. $(( 15 - (`date +%-M` % 15) )) Minuten"; fi
   fi
 fi

   #Sonnenscheinarray lesen
   SONNENSCHEIN_TMP=$(curl -s http://${IPP}/getPlainValue/${DP_SONNENSCHEIN_SAVE}|sed -e 's/\"//g')
   IFS=" "
   SON_ARY=($SONNENSCHEIN_TMP)
	SONNENSCHEIN_TAG=${SON_ARY[0]}
	SONNENSCHEIN_WO=${SON_ARY[1]}
	SONNENSCHEIN_MO=${SON_ARY[2]}
	SONNENSCHEIN_JAHR=${SON_ARY[3]}

   #Solarenergiearray lesen
   SOLAR_TMP=$(curl -s http://${IPP}/getPlainValue/${DP_SOLAR_SAVE}|sed -e 's/\"//g')
   SOL_ARY=($SOLAR_TMP)
	SOLARENERGIE_TAG=${SOL_ARY[0]:-0}
	SOLAR_WOCHE=${SOL_ARY[1]:-0}
	SOLAR_MONAT=${SOL_ARY[2]:-0}
	SOLAR_JAHR=${SOL_ARY[3]:-0}

   unset SOL_ARY; unset SON_ARY; unset SONNENSCHEIN_TMP; unset SOLAR_TMP

   #Startwerte setzen
   curl --data "${DP_WETTER_TREND}=${WETTER_TREND}" http://${IPP}/setBulk >/dev/null 2>&1
}


###Befehlszeilenparameter
usage() {
	echo -e "\nusage: wetterstation [[--debug] | [-s|--show] | [-d|--data] | [-v|--version] | [-h|--help]]\n"
	echo -e " --debug\teinmaliger Testdurchlauf mit Ausgabe"
	echo -e " -s | --show\tzeigt bei der Debug-Ausgabe Passwort und Station-ID im Klartext an"
	echo -e " -d | --data\tzeigt nur das gesendete Datenpaket der Wetterstation an"
	echo -e " -v | --version\tAusgabe der Versionsnummer"
	echo -e " -h | --help\tdieses Hilfemenue\n"
}

version() {
	echo -e "\n$BL ${SH_VER} - (c) 2019-2020 SBorg"
	echo -e " Config-Version: ${CONF_V}"
	echo -e " Sub-Version   : ${SUBVER}\n"
}

###EoF