gleitender Mittelwert in der laufenden loop zu langsam

hallo leute,

habe ein problem mit der performance eines (gleitenden) mittelwertes in meiner loop.

folgende situation:
eine led blinkt im 0,5sek takt. ich greife das licht über einen sensor ab.
soweit kein problem. mittelwert zwischen blinken und aus sind deutlich.
sobald aber meine loop läuft "stottert" das ganze.

im ersten versuch habe ich einen normalen mittelwert von 10 messungen gebildet, jedoch stoppt hier der ablauf, nicht schön ist.
im zweiten versuch habe ich einen gleitenden mittelwert versucht, aber dieser bekommt wohl pro loop nur einen wert.

ich hoffe ihr könnt mir weiter helfen ?!

die interessanten stellen sind zu beginn der loop und ganz ende


gruß

christian

code: [select]





// stepper1 hülsenmotor 5- 8
// stepper2 schubmotor  9-12
// d22 magnet
// d23 start
// d24 load
// d26 vibr
// d3 taster hülse
// d4 taster schub
// d25 schalter produktion
// a0 led load
// a1 led tabacco entfällt
// d2 servo entfällt
// d49 stop
// d28 taster vibr entfällt


#include <wire.h>

#include <adafruit_rgblcdshield.h>
#if defined(arduino_arch_samd)
#endif


adafruit_rgblcdshield lcd = adafruit_rgblcdshield();

// these #defines make easy set backlight color
#define red 0x1
#define yellow 0x3
#define green 0x2
#define teal 0x6
#define blue 0x4
#define violet 0x5
#define white 0x7


#include <accelstepper.h> //
#include <servo.h>


accelstepper stepper1(accelstepper::full4wire, 5, 6, 7, 8);
accelstepper stepper2(accelstepper::full4wire, 9, 10, 11, 12);


int var=0;                                      // für 20 mal load
int var2=0;                                     // zeit zur berechnung für 3 ziggis
long starttime;                                 // millis-wert beim ersten drücken der taste
long duration;                                  // variable für die dauer




#define rel0  23                                 //start                  
#define rel1  24                                //magnet                  
#define rel2  22                                 //load
#define rel3  26                                 //vibr

//servo myservo;  
//int pos = 0;    

int j = 0;                                      // für mittelwert
int spannung[10];

#define anzahlmittelwerte 10                    // für gleitender mittelwert
int werte[anzahlmittelwerte], zaehlermittelwerte=0;

void setup() {
  serial.begin(9600);
  lcd.begin(16, 2);
  lcd.print("  go fresh go  ");
  myservo.attach(2);
  stepper1.setmaxspeed(150);
  stepper2.setmaxspeed(270);
  stepper1.setacceleration(3000.0);
  stepper2.setacceleration(3000.0);
  
 
  pinmode(rel0, output);                            //magnet
  pinmode(rel1, output);                            //start
  pinmode(rel2, output);                            //load
  pinmode(rel3, output);                          //vibr
  pinmode(3, input_pullup);                         // taster hülsenmotor
  pinmode(4, input_pullup);                         // taster schubmotor
  pinmode(25, input_pullup);                         // schalter produktion
  pinmode(28, input_pullup);                        // taster vibr
  pinmode(49, input_pullup);                        // taster fehler
  digitalwrite(rel0, high);
  digitalwrite(rel2, high);
  digitalwrite(rel1, high);
  digitalwrite(rel3, high);
  int sensorval1 = digitalread(3);
  int sensorval2 = digitalread(4);
  int sensorval3 = digitalread(25);
  int sensorval4 =  digitalread(28);
  int sensorrel0 = digitalread(rel0);
  int sensorrel1 = digitalread(rel1);
  int sensorrel2 = digitalread(rel2);
  


lcd.setbacklight(white);

uint8_t i=0;
 
 while(sensorval1 == low) {                  // solange schalter nicht gedrückt  
 if (stepper1.distancetogo() == 0){          // homing hülsenmotor
 stepper1.move(-1);
 }
 stepper1.run();
 delay(10);
 sensorval1 = digitalread(3);  
 }


while(sensorval2 == high) {                  // solange schalter nicht gedrückt  
if (stepper2.distancetogo() == 0){           // homing schubmotor
 stepper2.move(1);
 }
 stepper2.run();
 delay(10);
 sensorval2 = digitalread(4);  
 }
 
 

 
 
}



void loop() {

  
  
  delay(100);
  
//myservo.writemicroseconds(1540);
//int sensorvalue1 = analogread(a0);                 //led load
//int sensorvalue2 = analogread(a1);                 //led tabacco

if (digitalread(25)==low) {                        // schalter produktion

//int n;                                                //für gleitender mittelwert
//  float f;                                            //für gleitender mittelwert
//  n=analogread(a0);                                   //für gleitender mittelwert
//  f= mittelwert(n);                                   //für gleitender mittelwert
//  serial.print("gleitender mittelwert     ");         //für gleitender mittelwert
//  serial.println(f);                                  //für gleitender mittelwert
//delay(100);                                           //für gleitender mittelwert
  
for (j=0; j<10;j++){                     // werte für mittelwert sammeln
delaymicroseconds(200) ;
spannung[j] = analogread(a0);
delaymicroseconds(50);
serial.println(spannung[j]);
delay(100);
}

                                          //mittelwert berechnen
long int mittelwert = 0;
for (int j=0; j<10;j++) {
mittelwert = mittelwert + long(spannung[j]);
}
mittelwert = mittelwert / 10;
serial.print("mittelwert = ");
serial.println(mittelwert);







  
stepper1.moveto(275);                            // fahre hülsenmotor zur aufnahme
while (stepper1.currentposition() != 275)
stepper1.run();
delay(170);

if (mittelwert <800){

stepper1.moveto(75);                             // fahre hülsenmotor zum abwurf
while (stepper1.currentposition() != 75)
stepper1.run();
delay(100);




 
      
digitalwrite(rel1, high);                             //löse magnet
stepper2.setspeed(250);
delay(100);
    
    
if (digitalread(49)==high) {                           // wenn schalter abbruch nicht gedrückt


var2++;                                                //zeitvariable
if (var2 == 1){
starttime = millis();
}
var++;                                                 //rundenvariable
lcd.setcursor(4, 1);
lcd.print("runde  ");
lcd.println(var);


digitalwrite(rel2, low);                            //aktiviere taste load
delay(500);
digitalwrite(rel2, high);
delay(500);
      
//stepper1.moveto(275);                             // fahre hülsenmotor zur aufnahme
//while (stepper1.currentposition() != 275)
//stepper1.run();


if(var == 19) {
digitalwrite(rel0, low);                             // aktiviere taster start
delay(1000);
digitalwrite(rel0, high);
delay(500);
serial.println("start gedrückt 19");
}

if(var == 20) {
digitalwrite(rel0, low);                             // aktiviere taster start
delay(1000);
digitalwrite(rel0, high);
delay(500);
serial.println("start gedrückt 20");
var = 0;
}


if (var2 == 3){
long duration = millis() - starttime;
serial.print("drei zigaretten dauern:  ");
serial.println(duration);
var2 = 0;
digitalwrite(rel3, low);
}
}                                                    //ende abbruch schleife  

digitalwrite(rel1, low);                             //aktiviere magnet
delay(500);

    
stepper2.setspeed(250);
stepper2.moveto(760);                                 // fahre schubmotor zum abwurf
while (stepper2.currentposition() != -10){
stepper2.run();}
digitalwrite(rel1, high);                             //löse magnet
delay(10);
digitalwrite(rel3, high);
}// ende schleife mittelwert
}// ende schleife taste produktion
//
//float mittelwert(int neuerwert) {
//// neuen int wert eingeben und den mittelwert als float zurück geben
////
//// matthias busse 9.2.2016 version 1.0
//float mittel, summe=0;
//
//  werte[zaehlermittelwerte] = neuerwert;
//  for(int k=0; k < anzahlmittelwerte; k++) summe += werte[k];
//  mittel=(float) summe / anzahlmittelwerte;
//  zaehlermittelwerte++;
//  if(zaehlermittelwerte >= anzahlmittelwerte) zaehlermittelwerte=0;
//  return mittel;
//}

}                                              // end loop




das ist kein gleitender mittelwert. darunter ist gemeint, dass man die messungen unterschiedlich gewichtet und ältere messungen mit weniger in das ergebnis eingehen. du bildest nur einen einfachen durchschnitt. x messungen machen und durch x dividieren


das ist alles sehr unsauber programmiert. alles in loop() gepfercht statt mal in funktionen auszulagern. und ständig delay(). wenn das blockierungsfreier wäre, wäre es auch kein problem nur eine messung pro durchlauf zu machen. einfach weil es öfters drankommt. das sieht wieder nach einer sache aus die nach einem zustandsautomaten schreit.

Arduino Forum > International > Deutsch (Moderator: uwefed) > gleitender Mittelwert in der laufenden loop zu langsam

arduino