gegevens middelen in skecth

[mattheijer Profiel Privébericht]

Goedendag,

ik ben met een aantal prjecten bezig een daarvan is een "weerstation"
de temp en RV worden door een DHT22 uitgelezen en netjes gelogd naar een database.
dit gebeurt iedere 10 minuten.
nu zou ik graag willen dat er in die 10 minuten iedere minuet een meting wordt gedaan deze dan per 10 minuten owrden optgeteld en daarna worden gedeeld door 10.

Wie zou mij kunnen helpen hoe dit op te lossen in mijn sketch.
hier is de sketch:
cpp code

#include <dht.h>    // zet de DHT libary aan
// #include "Wire.h"    // imports the wire library for talking over I2C 
#include "Adafruit_BMP085.h"  // import the Pressure Sensor Library
Adafruit_BMP085 mySensor;  // create sensor object called mySensor
#include <Ethernet.h>
#include <SPI.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(9, 8, 7, 6, 5, 3);
#define DHT22_PIN A0     // zet DHT22 op pin A0



 byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x01 }; // RESERVED MAC ADDRESS
 EthernetClient client;
dht DHT;                //zet dht als DHT

float t1;  // Variable for holding temp uit bmp180
float p; //Variable for holding pressure reading
float l;  // voor berekening van pa naar hpa
float v;  // variable voor vochtigheid
float t2; // variable voor temp van dht11


String data;

void setup(){
Serial.begin(9600);              //turn on serial monitor
mySensor.begin();                       //initialize mySensor
lcd.begin(16, 2);
lcd.clear();
 

  
 if (Ethernet.begin(mac) == 0) {
 Serial.println("Failed to configure Ethernet using DHCP"); 
  }

}

void loop() {
float chk = DHT.read22(DHT22_PIN);     //Spreek de DHT 22 aan
t1 = mySensor.readTemperature(); //  Read Temperature
l = mySensor.readPressure(); //Read Pressure
p = l/100;
v = DHT.humidity;
t2 = DHT.temperature;

  data = "temp1=" + String(t2) + "&hum1=" + String(v) + "&temp2=" +String(t1) + "&druk1=" + String(p);

  if (client.connect("worstenzo.com",80)) { // REPLACE WITH YOUR SERVER ADDRESS
   client.println("POST /drogen/add.php HTTP/1.1"); 
    client.println("Host: worstenzo.com"); // SERVER ADDRESS HERE TOO
    client.println("Content-Type: application/x-www-form-urlencoded"); 
    client.print("Content-Length: "); 
    client.println(data.length()); 
    client.println(); 
    client.print(data); 
    Serial.println(data);
    
      // lcd blok
      lcd.clear();
lcd.print("temp");// zet standaard tekst
lcd.print(t2);// vul waarde in
lcd.setCursor(9,0);// laat volgende print elders beginnen
lcd.print("RV");// zet standaard tekst
lcd.print(v);//vul waarde in
lcd.setCursor(0,1);//laat cursor op tweede regel beginnen
lcd.print("luchtdruk");//zet standaard tekst
lcd.print(p);//vul waarde in

// delay(1000);
// lcd.clear();
  }

 if (client.connected()) { 
   client.stop();  // DISCONNECT FROM THE SERVER
  
   delay(600000);
}

}

[Koepel Profiel Privébericht]

Ben je bekend met millis() ? Dan kun je verschillende delays en intervals los van elkaar doen.
Maar daarvoor moet de structuur van de sketch helemaal anders.


Een eenvoudige oplossing is om 1 minuut te wachten en 1 op de 10 keer de data te uploaden.
De "1 op 10 keer" betekend dat je een tellertje nodig hebt die tot 10 telt.
Dus bijvoorbeeld een globale variabele : int tel_tot_tien; // verzin zelf een betere naam
In de loop() een delay van 1 minuut in plaats van 10 minuten.
De teller ophogen, en als de teller 10 is, dan de teller nul maken en de data uploaden.
Probeer er maar wat van te maken, en laat ons je sketch zien. Kun je "Code" tags gebruiken ?


Gaat dit goed ?

Code: Alles selecteren

delay(600000);


Voor een Arduino Uno is de default een integer van 16 bit. Die 600000 is te groot voor een integer. Je kunt er een "L" achter zetten om aan te geven dat het een long is, of een "UL" voor unsigned long.

Code: Alles selecteren

delay(600000);   // zo is het
delay(600000L);   // beter
delay( 10L * 60L * 1000L); // zo zou ik het doen


Ik hoop niet dat je Ethernet en een String object in een Arduino Uno (of een Nano/Pro Mini/Micro) gebruikt. Vanwege het Kaboom scenario : https://learn.adafruit.com/memories-of-an-arduino/solving-memory-problems.

[mattheijer Profiel Privébericht]

Ben je bekend met millis() ? Dan kun je verschillende delays en intervals los van elkaar doen.
Maar daarvoor moet de structuur van de sketch helemaal anders.


Een eenvoudige oplossing is om 1 minuut te wachten en 1 op de 10 keer de data te uploaden.
De "1 op 10 keer" betekend dat je een tellertje nodig hebt die tot 10 telt.
Dus bijvoorbeeld een globale variabele : int tel_tot_tien; // verzin zelf een betere naam
In de loop() een delay van 1 minuut in plaats van 10 minuten.
De teller ophogen, en als de teller 10 is, dan de teller nul maken en de data uploaden.
Probeer er maar wat van te maken, en laat ons je sketch zien. Kun je "Code" tags gebruiken ?


Gaat dit goed ?

Code: Alles selecteren

delay(600000);


Voor een Arduino Uno is de default een integer van 16 bit. Die 600000 is te groot voor een integer. Je kunt er een "L" achter zetten om aan te geven dat het een long is, of een "UL" voor unsigned long.

Code: Alles selecteren

delay(600000);   // zo is het
delay(600000L);   // beter
delay( 10L * 60L * 1000L); // zo zou ik het doen


Ik hoop niet dat je Ethernet en een String object in een Arduino Uno (of een Nano/Pro Mini/Micro) gebruikt. Vanwege het Kaboom scenario : https://learn.adafruit.com/memories-of-an-arduino/solving-memory-problems.

Vooralsnog gaat de 600000 goed doet er niets kaboom, de temp tabel op www.worstenzo.com laat zien dat er om de 10 minuten een waarde in de DB wordt gezet.
maar die delay ga ik aanpassen.
voor wat betreft de teller snap ik wat je bedoeldt maar hoe geef je dan aan dat hij die 10 waardes opslaat optelt en door 10 deelt ?
uiteindelijk wil ik van die 10 getallen een gemiddelde hebben.

[shooter Profiel Privébericht]

haal een paar dingen uit de loop en zet deze apart in een functie, ofwel de scan, de tekstmaker en de lcd allemaal apart in een functie.
dan kun je elke functie aanroepen als er een tijd voorbij is (en dat doe je met millis().

een egmiddelde is een kwestie van een teller bijhouden, en de waardes dus optellen bij elkaar, en als deze teller op 10 staat de getallen door 10 delen, en aanbieden aan de tekstmaker.
doe de lcd vaak updaten (elke seconde of zo, dan is deze actueel)

[Koepel Profiel Privébericht]

@mattheijer, het is niet nodig om mijn hele bericht te quoten hoor, wat ik schreef staat er al

Dit is met een tellertje:

Code: Alles selecteren

// globale teller
int count10 = 0;

void setup()
{
  Serial.begin( 9600);
  Serial.println(F( "\nTest met tien teller"));
}

void loop()
{
  // The loop runs every second

  Serial.print(".");             // print dot every second

  count10++;       // increment
  if( count10 == 10)
  {
    count10 = 0;    // start again
   
    Serial.println(" en dat is tien !");
  }

  delay( 1000);
}


De volgende stap is om het gemiddelde te nemen. Ik zou gewoon alles optellen, en bij de tiende keer het totaal door tien delen.

Ik ben het helemaal met shooter eens. Splits je sketch op in afzonderdelijke stukken (bijvoorbeeld met functies). En als je het display vaker wilt updaten dan ga je al snel richting het gebruik van millis().
Ook al ga je millis() niet gebruiken, laat alvast een ledje knipperen met millis() en kijk of je het begrijpt : https://www.arduino.cc/en/Tutorial/BlinkWithoutDelay

[mattheijer Profiel Privébericht]

Koepel en shooter bedankt voor jullie info/hulp/

Koepel sorry voor de lange quote.

De teller snap ik inmiddels ga nu eens uitzoeken hoe ik die tien dan bij elkaar kan laten optellen en weer kan delen.

Shooter de functie waar jij het over hebt snap ik niet zo goed maar ik ga hier maar eens voor googlen

[FPCUser Profiel Privébericht]

Je kan de meetwaarden opslaan in een array die je gebruikt als buffer.
Stel je wilt een 1 minuut waarde als gemiddelde hebben en je meet elke 12 seconden.
Je buffer is bevat dan 5 elementen.

Om het voorschrjdend gemiddelde te bepalen haal je de oudste uit je som en stop je de
nieuwe waarde erin. Bepaal gemiddelde en verhoog dan je index die de oudste waarde aangeeft.

cpp code

#define N_MA 5                // aantal metingen voortschrijdend gemiddelde
float T_ma;                   // voortschrijdend gemiddelde temperatuur in °C
float T_buffer[N_MA];         // buffer voor temperatuur metingen
unsigned char T_oud = 0;      // index voor deze buffer
float T_som;                  // som van de laatste N_Tma temperatuurmetingen

/*
 * Algemene functie voortschrijdend gemiddelde
 */
float Calc_MA(float meetwaarde, float buffer[], unsigned char &oudste, float &som) {
  if (oudste >= N_MA)
    oudste = 0;
  som -= buffer[oudste];
  som += meetwaarde;
  buffer[oudste] = meetwaarde;
  oudste += 1;
  return som / N_MA;
}

[mattheijer Profiel Privébericht]

Dank FPCUser,

voortschrijdend gemiddelde kan heel handig zijn maar is niet wat ik hier wil hebben.
eigenlijk wil ik een minuut lang meting doen deze bij elkaar optellen en dan delen door het aantal metingen.
En dat iedere minuut weer.

[Koepel Profiel Privébericht]

@mattheijer, Met een voortschrijdend gemiddelde zoals FPCUser voorstelt, heb je op ieder willekeurig moment het gemiddelde van de laatste 10 samples. Dus als je alle intervals en delays onafhankelijk elkaar maakt met millis(), dan is het voortschrijdend gemiddelde de mooiste oplossing.
Op dit moment kun je het doen zonder al die bling-bling, en is tien samples optellen en het gemiddelde berekenen voldoende.

Uhm, een vraagje. Begrijp je niet hoe je blokken met een bepaalde functionaliteit in een functie zet of denk je dat 'egmiddelde' een magische functie is die een portal vormt naar een parallel universum waar je sketch al klaar staat ?

Hieronder een voorbeeld met tien samples optellen. De samples zijn een random van 0 tot 1000, dus het gemiddelde zou in de buurt van de 500 uitkomen. Probeer maar.
cpp code

// globale teller
int count10 = 0;
float total10 = 0.0;


void setup() 
{
  Serial.begin( 9600);
  Serial.println(F( "\nTest met average over tien samples"));
}

void loop() 
{
  // The loop runs every second

  float sample = (float) random( 0, 1001);  // grab a sample
  total10 += sample;                        // add everything to a total


  count10++;                               // increment
  if( count10 == 10)                       // this is the 10th time ?
  {
    count10 = 0;    // start again
    
    float average = total10 / 10.0;        // average is total divided by number of samples.
    Serial.print( "Average = ");
    Serial.println( average);
    total10 = 0.0;                         // clear total for next round
  }

  delay( 1000);
}

[mattheijer Profiel Privébericht]

Uhm, een vraagje. Begrijp je niet hoe je blokken met een bepaalde functionaliteit in een functie zet of denk je dat 'egmiddelde' een magische functie is die een portal vormt naar een parallel universum waar je sketch al klaar staat ?

hahaha nee hoe je die blokken in een functie zet snap ik niet helemaal.

voortschrijdendgemiddelde heb ik niet nodig omdat ik eigenlijk per minuut een gemiddelde wil hebben.
Die vervolgens later op een website wordt verwerkt.

Voor mijn volgende project (doorgkast om worst te dorgen) denk ik dat het wel eens heel handig kan zijn.
Hier moet de temp in een koelkast gemeten worden en vevolgens op 20 graden worden gehouden.
De arduino moet dan de koelkast gaan schakelen.
ik denk dat voortschrijdend middelen dan wel eens handig kan zijn.
Ook daar moet weer een teller bij ingebouwd worden omdat een koelkast maar 6 maal per uur mag aanslan anders vebrand de motor.

En nee een magische functie geloof ik niet meer in hahahaha

Morgen ga ik met dit draadje aan de slag iedereen bedankt voor alle info