Basis Flux Queries

Dit document bevat basis query templates voor het ophalen en verwerken van verschillende meetgegevens uit de Bries database.

Generieke meetwaarden query

Dit is een generiek template dat kan worden aangepast voor verschillende metingen:

// Vervang MEASUREMENT_CATEGORY door een van de beschikbare categorieën (Wspeed, Wdir, etc.)
// Vervang DISPLAY_NAME door een leesbare naam voor weergave in Grafana (bijv. "Wind speed")
// Vervang OUTPUT_NAME door een naam voor de resultaatset (bijv. "wind_speed")

data = from(bucket: bucketName)
  |> range(start: minTime, stop: maxTime)  // Gebruik de berekende tijdsperiode
  |> filter(fn: (r) => r._measurement == "MEASUREMENT_CATEGORY" and r.runID == runID)
  |> filter(fn: (r) => r._field == "value")  // Of andere veldnaam indien nodig
  |> map(fn: (r) => ({ r with _value: float(v: r._value) }))  // Zorg dat waarden float zijn
  |> aggregateWindow(every: 100ms, fn: mean, createEmpty: true)  // Gemiddelde per 100ms
  |> fill(column: "_value", usePrevious: true)  // Vul ontbrekende waarden in
  |> map(fn: (r) => ({_value: r._value, _time: r._time, _field: "DISPLAY_NAME"}))
  |> yield(name: "OUTPUT_NAME")

Specifieke metingen

Windsnelheid (Wspeed) query

wspeed = from(bucket: "Bries")
  |> range(start: minTime, stop: maxTime)
  |> filter(fn: (r) => r._measurement == "Wspeed" and r.runID == runID)
  |> filter(fn: (r) => r._field == "value")
  |> map(fn: (r) => ({ r with _value: float(v: r._value) }))
  |> aggregateWindow(every: 100ms, fn: mean, createEmpty: true)
  |> fill(column: "_value", usePrevious: true)
  |> map(fn: (r) => ({_value: r._value, _time: r._time, _field: "Wind speed"}))
  |> yield(name: "wind_speed")

Voertuigsnelheid (Vspeed) query

vspeed = from(bucket: "Bries")
  |> range(start: minTime, stop: maxTime)
  |> filter(fn: (r) => r._measurement == "Vspeed" and r.runID == runID)
  |> filter(fn: (r) => r._field == "value")
  |> map(fn: (r) => ({ r with _value: float(v: r._value) }))
  |> aggregateWindow(every: 100ms, fn: mean, createEmpty: true)
  |> fill(column: "_value", usePrevious: true)
  |> map(fn: (r) => ({_value: r._value, _time: r._time, _field: "Vehicle speed"}))
  |> yield(name: "vspeed")

Rotorsnelheid (Rspeed) query

rspeed = from(bucket: "Bries")
  |> range(start: minTime, stop: maxTime)
  |> filter(fn: (r) => r._measurement == "Rspeed" and r.runID == runID)
  |> filter(fn: (r) => r._field == "value")
  |> map(fn: (r) => ({ r with _value: float(v: r._value) })) 
  |> aggregateWindow(every: 100ms, fn: mean, createEmpty: true)
  |> fill(column: "_value", usePrevious: true)
  |> map(fn: (r) => ({_value: r._value, _time: r._time, _field: "Rotor speed"}))
  |> yield(name: "Rotor speed")

Rotorkoppel (Rtorque) query

rtorque = from(bucket: "Bries")
  |> range(start: minTime, stop: maxTime)
  |> filter(fn: (r) => r._measurement == "Rtorque" and r.runID == runID)
  |> filter(fn: (r) => r._field == "value")
  |> map(fn: (r) => ({ r with _value: float(v: r._value) })) 
  |> aggregateWindow(every: 100ms, fn: mean, createEmpty: true)
  |> fill(column: "_value", usePrevious: true)
  |> map(fn: (r) => ({_value: r._value, _time: r._time, _field: "Turbine koppel"}))
  |> yield(name: "Turbine koppel")

Pitch hoek query

pitch = from(bucket: "Bries")
  |> range(start: minTime, stop: maxTime)
  |> filter(fn: (r) => r._measurement == "pitch" and r.runID == runID)
  |> filter(fn: (r) => r._field == "value")
  |> map(fn: (r) => ({ r with _value: float(v: r._value) })) 
  |> aggregateWindow(every: 100ms, fn: mean, createEmpty: true)
  |> fill(column: "_value", usePrevious: true)
  |> map(fn: (r) => ({_value: r._value, _time: r._time, _field: "pitch"}))
  |> yield(name: "pitch")

Windrichting (Wdir) query

wdir = from(bucket: "Bries")
  |> range(start: minTime, stop: maxTime)
  |> filter(fn: (r) => r._measurement == "Wdir" and r.runID == runID)
  |> filter(fn: (r) => r._field == "value")
  |> map(fn: (r) => ({ r with _value: float(v: r._value) })) 
  |> aggregateWindow(every: 100ms, fn: mean, createEmpty: true)
  |> fill(column: "_value", usePrevious: true)
  |> map(fn: (r) => ({_value: r._value, _time: r._time, _field: "Wind direction"}))
  |> yield(name: "wind direction")

Rotor Drag query (loadcell)

loadcell = from(bucket: "Bries")
  |> range(start: minTime, stop: maxTime)
  |> filter(fn: (r) => r._measurement == "loadcell" and r.runID == runID)
  |> filter(fn: (r) => r._field == "value")
  |> map(fn: (r) => ({ r with _value: float(v: r._value) })) 
  |> aggregateWindow(every: 100ms, fn: mean, createEmpty: true)
  |> fill(column: "_value", usePrevious: true)
  |> map(fn: (r) => ({_value: r._value, _time: r._time, _field: "Rotor Drag"}))
  |> yield(name: "Rotor Drag")

Events en aantekeningen ophalen

from(bucket: "Bries")
  |> range(start: minTime, stop: maxTime)
  |> filter(fn: (r) => 
    r._measurement == "events" and
    r.runID == "${RunID}" and
    r._field == "annotation"
  )
  |> keep(columns: ["_time", "_value"])
  |> rename(columns: {_value: "text"})

Aggregatie en data transformatie

Aggregeren over een tijdsperiode

Een aggregatie van 100ms betekent dat de data wordt samengevoegd in tijdsvensters van 100ms. Dit kan helpen om ruis te verminderen en een duidelijker beeld te krijgen van de trends in de data.

// Vervang WINDOW_SIZE door gewenste tijdsperiode (bijv. 1m, 10s)
|> aggregateWindow(every: 100ms, fn: mean, createEmpty: false)

Ontbrekende waarden invullen

|> fill(column: "_value", usePrevious: true)  // Vul ontbrekende waarden in met de vorige waarde

Eerste afgeleide berekenen

// Berekent de veranderingssnelheid van een waarde
|> derivative(unit: 1s, nonNegative: false)

Drempelwaardefiltering

// Filtert op waarden boven een bepaalde drempel
|> filter(fn: (r) => r._value > THRESHOLD_VALUE)

Meerdere gegevenssets samenvoegen

// Haal verschillende meetgegevens op
dataset1 = from(bucket: bucketName)
  |> range(start: minTime, stop: maxTime)
  |> filter(fn: (r) => r._measurement == "MEASUREMENT_1" and r.runID == runID)
  // ...verdere verwerking...

dataset2 = from(bucket: bucketName)
  |> range(start: minTime, stop: maxTime)
  |> filter(fn: (r) => r._measurement == "MEASUREMENT_2" and r.runID == runID)
  // ...verdere verwerking...

// Voeg datasets samen voor weergave in één grafiek
union(tables: [dataset1, dataset2])
  |> yield(name: "combined_data")

Tijdsbereik instellen

Gebruiken van RunID tijdsselectie

Gebruik de minTime en maxTime variabelen die bepaald zijn door de RunID tijdsselectie:

|> range(start: minTime, stop: maxTime)

Direct Grafana tijdsbereik gebruiken

Voor queries die direct het Grafana tijdsbereik moeten gebruiken:

|> range(start: v.timeRangeStart, stop: v.timeRangeStop)