admin/sensorapi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Works now for noise sensors

Browse Source
This commit is contained in:
rxf
2023-03-24 13:50:32 +01:00
parent 088005c040
commit 836d2848b6
2 changed files with 178 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files
actions/getsensorData.js
+2 -2
View File
@@ -132,8 +132,8 @@ export const getSensorData = async (params) => {
export const getActData = async (opts, props) => {
let ret = {values: [], props: props, err: null}
export const getActData = async (opts) => {
let ret = {err: null, values: []}
let sorting = ''
if(opts.sort) {
if (opts.sort === 1) {
sensorspecials/noise.js
+176 -187
View File
@@ -8,6 +8,7 @@ import {getOneProperty} from "../actions/getproperties.js";
import * as ERR from "../utilities/errortexts.js"
import {DateTime} from 'luxon'
import {getData4map} from "../actions/data4map.js";
import {NODATA} from "../utilities/errortexts.js";
const setoptionfromtable = (opt,tabval) => {
let ret = opt
@@ -42,18 +43,24 @@ export const getNoiseData = async (params, possibles, props) => {
let {start, stop} = calcRange(opts) // calc time range
opts.start = start
opts.stop = stop
let erg = await x.func(opts, props) // get the data
ret.sid = opts.sensorid
ret.start = opts.start.slice(7)
ret.span = opts.span
if ((x.what === 'havg') || (x.what === 'davg')) {
ret.average = x.avg
ret.peak = opts.peak
let erg = await x.func(opts) // get the data
ret = {
err: erg.err,
sid: opts.sensorid,
indoor: props.location[0].indoor,
span: opts.span,
start: opts.start.slice(7),
data: opts.data,
peak: opts.peak,
count: erg.values.length,
values: erg.values,
}
if (!x.peak) {
delete ret.peak
}
if(ret.values.length === 0) {
ret.err = ERR.NODATA
}
ret.count = erg.values.length
ret.values = erg.values
ret.err = erg.err
ret.props = erg.props
return ret
}
}
@@ -85,9 +92,8 @@ export const getNoiseData = async (params, possibles, props) => {
// ....
//
// *********************************************
const getLiveData = async (opt, props) => {
let retur = {sid: opt.sensorid, span: opt.span, start: opt.datetime, count: 0, values: [], err: null};
return await getActData(opt, props)
const getLiveData = async (opt) => {
return await getActData(opt)
}
@@ -117,19 +123,21 @@ const getLiveData = async (opt, props) => {
// ....
//
// *********************************************
const gethavgData = async (opts) => {
const gethavgData = async (opts, props) => {
let e = await getNoiseAVGData(opts)
if (opts.csv) {
let csvStr = "datetime,n_AVG,peakcount\n";
for (let item of e) {
if (item.n_AVG != -1) {
csvStr += item.datetime + ',' + item.n_AVG + ',' + item.peakcount + '\n'
let csvStr = "datetime,n_AVG,peakcount\n"
if(!e.err) {
for (let item of e) {
if (item.n_AVG != -1) {
csvStr += item.datetime + ',' + item.n_AVG + ',' + item.peakcount + '\n'
}
}
}
return csvStr;
return csvStr
} else {
return e
return {err: e.err, values: e.values}
}
}
@@ -163,43 +171,36 @@ async function getdavgData(opts) {
let erg = await getNoiseAVGData(opts);
let val = [];
let csvStr = 'datetime,n_AVG,peakcount\n';
for (let i = 0; i < erg.length; i+=24) {
let sum = 0;
let count = 0;
let pk = 0;
let werte = {};
for(let k=0; k<24; k++) {
if (( erg[i+k] != null) && (erg[i+k].n_sum != -1)) {
sum += erg[i + k].n_sum;
count += erg[i + k].count;
pk += erg[i + k].peakcount;
if (werte.datetime === undefined) {
if(!erg.err) {
for (let i = 0; i < erg.length; i += 24) {
let sum = 0;
let count = 0;
let pk = 0;
let werte = {};
for (let k = 0; k < 24; k++) {
if ((erg[i + k] != null) && (erg[i + k].n_sum != -1)) {
sum += erg[i + k].n_sum;
count += erg[i + k].count;
pk += erg[i + k].peakcount;
if (werte.datetime === undefined) {
let dt = DateTime.fromISO(erg[i + k].datetime, {zone: 'utc'})
werte.datetime = dt.startOf('day').toISO()
}
}
}
}
werte.n_AVG = 10 * Math.log10( sum/count);
werte.peakcount = pk;
if (opts.csv) {
csvStr += werte.datetime + ',' + werte.n_AVG + ',' + werte.peakcount + '\n'
} else {
val.push(werte);
werte.n_AVG = 10 * Math.log10(sum / count);
werte.peakcount = pk;
if (opts.csv) {
csvStr += werte.datetime + ',' + werte.n_AVG + ',' + werte.peakcount + '\n'
} else {
val.push(werte);
}
}
}
if (opts.csv) {
return csvStr;
} else {
return val
// {
// sid: opts.sensorid,
// span: opts.span,
// start: opts.start.slice(7),
// 'average': 'day',
// peak: opts.peak,
// count: val.length,
// values: val
// };
return {err: erg.err, values: val}
}
}
@@ -237,70 +238,64 @@ async function getdaynightData(opts) {
let erg = await getNoiseAVGData(opts);
let val = [];
let csvStr = 'datetime,n_dayAVG,n_nightAVG\n';
let done = false;
let dt;
// The received houerly data array always (!!) starts at 0h00 local (!) time.
// So to calculate day values, we skip the first 6 hour and start from there
// now we add 16 hour for day and following 8 hour for night
for (let i = 6; i < erg.length;) {
let dsum = 0, dcnt = 0;
let nsum = 0, ncnt = 0;
let werte = {};
for (let k = 0; k < 16; k++, i++) {
if(erg[i].n_sum != -1) {
if (werte.datetime === undefined) {
let dt = DateTime.fromISO(erg[i].datetime, {zone: 'utc'})
werte.datetime = dt.startOf('day').toISO()
}
dsum += erg[i].n_sum;
dcnt += erg[i].count;
}
}
if (i < (erg.length - 8)) {
for (let k = 0; k < 8; k++, i++)
{
if(erg[i].n_sum != -1) {
if(!erg.err) {
let done = false;
let dt;
// The received houerly data array always (!!) starts at 0h00 local (!) time.
// So to calculate day values, we skip the first 6 hour and start from there
// now we add 16 hour for day and following 8 hour for night
for (let i = 6; i < erg.length;) {
let dsum = 0, dcnt = 0;
let nsum = 0, ncnt = 0;
let werte = {};
for (let k = 0; k < 16; k++, i++) {
if (erg[i].n_sum != -1) {
if (werte.datetime === undefined) {
let dt = DateTime.fromISO(erg[i].datetime, {zone: 'utc'})
werte.datetime = dt.startOf('day').toISO()
}
nsum += erg[i].n_sum;
ncnt += erg[i].count;
dsum += erg[i].n_sum;
dcnt += erg[i].count;
}
}
} else {
done = true;
}
if (dcnt != 0) {
werte.n_dayAVG = 10 * Math.log10(dsum / dcnt);
} else {
werte.n_dayAVG = 0;
}
if (ncnt != 0) {
werte.n_nightAVG = 10 * Math.log10(nsum / ncnt);
} else {
werte.n_nightAVG = 0;
}
if (opts.csv) {
csvStr += werte.datetime + ',' + werte.n_dayAVG + ',' + werte.n_nightAVG + '\n'
} else {
val.push(werte);
}
if (done) {
break;
if (i < (erg.length - 8)) {
for (let k = 0; k < 8; k++, i++) {
if (erg[i].n_sum != -1) {
if (werte.datetime === undefined) {
let dt = DateTime.fromISO(erg[i].datetime, {zone: 'utc'})
werte.datetime = dt.startOf('day').toISO()
}
nsum += erg[i].n_sum;
ncnt += erg[i].count;
}
}
} else {
done = true;
}
if (dcnt != 0) {
werte.n_dayAVG = 10 * Math.log10(dsum / dcnt);
} else {
werte.n_dayAVG = 0;
}
if (ncnt != 0) {
werte.n_nightAVG = 10 * Math.log10(nsum / ncnt);
} else {
werte.n_nightAVG = 0;
}
if (opts.csv) {
csvStr += werte.datetime + ',' + werte.n_dayAVG + ',' + werte.n_nightAVG + '\n'
} else {
val.push(werte);
}
if (done) {
break;
}
}
}
if (opts.csv) {
return csvStr;
} else {
return val
// {
// sid: opts.sensorid,
// span: opts.span,
// start: opts.start.slice(7),
// count: val.length,
// values: val
// };
return {err: erg.err, values: val}
} }
// *********************************************
@@ -334,88 +329,79 @@ async function getLdenData(opts) {
let erg = await getNoiseAVGData(opts);
let val = [];
let csvStr = 'datetime,lden\n';
let done = false;
const calcAVG = (sum,cnt) => {
if (cnt != 0) {
return (10 * Math.log10(sum / cnt));
} else {
return 0;
if(!erg.err) {
let done = false;
const calcAVG = (sum, cnt) => {
if (cnt != 0) {
return (10 * Math.log10(sum / cnt));
} else {
return 0;
}
}
}
// The received hourly data array always (!!) starts at 0h00 local (!) time.
// So to calculate day values, we skip the first 6 hour and start from there
// now we add 12 hour for day and following 4 hour for evening and
// additional 8 hours for night
for (let i = 6; i < erg.length;) {
let dsum = 0, dcnt = 0;
let nsum = 0, ncnt = 0;
let esum = 0, ecnt = 0;
let werte = {};
let dayAVG = 0, evnAVG = 0, nightAVG = 0;
for (let k = 0; k < 12; k++, i++) {
if (erg[i].n_sum != -1)
{
if (werte.datetime == undefined) {
werte.datetime = erg[i].datetime;
}
dsum += erg[i].n_sum;
dcnt += erg[i].count;
}
}
for (let k = 0; k < 4; k++, i++) {
if (erg[i].n_sum != -1)
{
if (werte.datetime == undefined) {
werte.datetime = erg[i].datetime;
}
esum += erg[i].n_sum;
ecnt += erg[i].count;
}
}
if (i < (erg.length - 8)) {
for (let k = 0; k < 8; k++, i++)
{
if (erg[i].n_sum != -1)
{
// The received hourly data array always (!!) starts at 0h00 local (!) time.
// So to calculate day values, we skip the first 6 hour and start from there
// now we add 12 hour for day and following 4 hour for evening and
// additional 8 hours for night
for (let i = 6; i < erg.length;) {
let dsum = 0, dcnt = 0;
let nsum = 0, ncnt = 0;
let esum = 0, ecnt = 0;
let werte = {};
let dayAVG = 0, evnAVG = 0, nightAVG = 0;
for (let k = 0; k < 12; k++, i++) {
if (erg[i].n_sum != -1) {
if (werte.datetime == undefined) {
werte.datetime = erg[i].datetime;
}
nsum += erg[i].n_sum;
ncnt += erg[i].count;
dsum += erg[i].n_sum;
dcnt += erg[i].count;
}
}
} else {
done = true;
}
dayAVG = calcAVG(dsum, dcnt);
evnAVG = calcAVG(esum, ecnt);
nightAVG = calcAVG(nsum, ncnt);
// Calculate LDEN:
let day = 12 * Math.pow(10,dayAVG/10); // ... and calculate the LDEN values following ...
let evn = 4 * Math.pow(10, (evnAVG+5)/10); // ... the LDEN formaula (see function description)
let night = 8 * Math.pow(10,(nightAVG+10)/10);
werte.lden = 10 * Math.log10((day+evn+night)/24);
if (opts.csv) {
csvStr += werte.datetime + ',' + werte.lden + '\n'
} else {
val.push(werte);
}
if (done) {
break;
for (let k = 0; k < 4; k++, i++) {
if (erg[i].n_sum != -1) {
if (werte.datetime == undefined) {
werte.datetime = erg[i].datetime;
}
esum += erg[i].n_sum;
ecnt += erg[i].count;
}
}
if (i < (erg.length - 8)) {
for (let k = 0; k < 8; k++, i++) {
if (erg[i].n_sum != -1) {
if (werte.datetime == undefined) {
werte.datetime = erg[i].datetime;
}
nsum += erg[i].n_sum;
ncnt += erg[i].count;
}
}
} else {
done = true;
}
dayAVG = calcAVG(dsum, dcnt);
evnAVG = calcAVG(esum, ecnt);
nightAVG = calcAVG(nsum, ncnt);
// Calculate LDEN:
let day = 12 * Math.pow(10, dayAVG / 10); // ... and calculate the LDEN values following ...
let evn = 4 * Math.pow(10, (evnAVG + 5) / 10); // ... the LDEN formaula (see function description)
let night = 8 * Math.pow(10, (nightAVG + 10) / 10);
werte.lden = 10 * Math.log10((day + evn + night) / 24);
if (opts.csv) {
csvStr += werte.datetime + ',' + werte.lden + '\n'
} else {
val.push(werte);
}
if (done) {
break;
}
}
}
if (opts.csv) {
return csvStr;
} else {
return val
// {
// sid: opts.sensorid,
// span: opts.span,
// start: opts.start.slice(7),
// count: val.length,
// values: val
// };
return {err: erg.err, values: val}
}
}
@@ -425,18 +411,18 @@ const getAPIprops = (opt) => {
}
const whatTable = [
{'what':'live', 'span': 1, 'daystart': false, avg: null, 'func': getLiveData},
{'what':'havg', 'span': 30, 'daystart': true, avg: 'hour', 'func': gethavgData},
{'what':'davg', 'span': 30, 'daystart': true, avg: 'day', 'func': getdavgData},
{'what':'daynight', 'span': 30, 'daystart': true, avg: null, 'func': getdaynightData},
{'what':'lden', 'span': 30, 'daystart': true, avg: null, 'func': getLdenData},
{'what':'props', 'span': 0, 'daystart': true, avg: null, 'func': getAPIprops},
{'what':'live', 'span': 1, 'daystart': false, peak: false, 'func': getLiveData},
{'what':'havg', 'span': 7, 'daystart': true, peak: true, 'func': gethavgData},
{'what':'davg', 'span': 30, 'daystart': true, peak: true, 'func': getdavgData},
{'what':'daynight', 'span': 30, 'daystart': true, peak: false, 'func': getdaynightData},
{'what':'lden', 'span': 30, 'daystart': true, peak: false, 'func': getLdenData},
{'what':'props', 'span': 0, 'daystart': true, peak:false, 'func': getAPIprops},
];
const getNoiseAVGData = async (opts) => {
let ret = {data: {count: 0, values: []}, err: null}
let emptyValues = {n_AVG:-1};
let ret = {err: null, values: []}
let emptyValues = {n_AVG:-1}
let small = '|> keep(columns: ["_time", "peakcount", "n_AVG"])'
if (opts.long) {
small = ''
@@ -469,7 +455,7 @@ esum = data
|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")
|> rename(columns: {"E10tel_eq" : "n_sum"})
peak = data
|> filter(fn: (r) => r._field == "noise_LAeq")
|> filter(fn: (r) => r._field == "noise_LA_max")
|> aggregateWindow(
every: 1h,
fn: (column, tables=<-) => tables
@@ -489,9 +475,12 @@ peak = data
join( tables: {P1: part1, P2: part2}, on: ["_time"])
${small}
`
let erg = await fetchFromInflux(ret, queryAVG)
if(erg.err) {
return returnOnError(ret, err, getNoiseAVGData.name)
ret = await fetchFromInflux(ret, queryAVG)
if(ret.err) {
return returnOnError(ret, ret.err, getNoiseAVGData.name)
}
if(ret.values.length === 0) {
return returnOnError(ret, ERR.NODATA, getNoiseAVGData.name)
}
// The times are always the END of the period (so: period from 00:00h to 01:00h -> time is 01:00)
@@ -500,9 +489,9 @@ peak = data
// index will be incremented by 24). Missing values are marked by: {n_sum=-1, n_AVG=-1}.
let hoursArr = new Array(opts.span * 24); // generate new array
hoursArr.fill(emptyValues); // fill array with 'empty' values
let startDay = DateTime.fromISO(erg.values[0].datetime, {zone: 'utc'}).get('day'); // calc first day
let startDay = DateTime.fromISO(ret.values[0].datetime, {zone: 'utc'}).get('day'); // calc first day
let k = 0;
for (let d of erg.values) { // loop through docs
for (let d of ret.values) { // loop through docs
let stunde = DateTime.fromISO(d.datetime, {zone: 'utc'}).get('hour') // get current hour
let day = DateTime.fromISO(d.datetime, {zone: 'utc'}).get('day') // get current day
if (day != startDay) { // if date has changed