Code: Alles auswählen

// ------------------------
// median filter by RAU
// Ratingen 25.03.2016
// for the public domain
// ------------------------
// Median filter for a serial data stream.
// Stores a static array with the last 3/5/7/... values of the data stream.
// Each call remplaces the oldest value of the array by the new one.
// The median value, which is in the middle of the ordered array, is returned.
// Fast processing: Only one loop. Ring structure instead of shift register.
// Order of unchanged values is reused and incrementally updated.
// Initialization at the first call: The array is filled with the first value.
// Sorry, only one channel. Copy complete function with renamed constants for more.
// (This allows to use different data types and compiles into faster code.)

#define storageSize 7  // size of filter, only odd numbers 3/5/7/... allowed
#define medianPos  3   // position of median in ordered list: (storageSize-1)/2,
                       // don't let the processor calculate this in the loop
#define medianType int // type of data values (int/long/float/...)

medianType median(medianType newVal) {
	static int init = 1; // init flag
	static medianType storageVal[storageSize]; // array of values
	static medianType storageOrd[storageSize]; // array of order numbers
	static int actual = 0; // actual index of the ring storage
	medianType returnVal = newVal; // the new value could be the median

	if (init) {
		// initialization of arrays
		int i;
		for (i=0; i<storageSize; i++) {
			storageVal[i] = newVal; // fill array with new value
			storageOrd[i] = i;      // just spread all order values
		}
		init = 0; // don't run initialization again
	} else {
		// store new value
		if (++actual >= storageSize) actual=0; // go one step in ring storage
		medianType oldVal = storageVal[actual]; // save old value
		int oldOrd = storageOrd[actual]; // save old order number
		storageVal[actual] = newVal; // store new value
		storageOrd[actual] = 0; // reset order number for new value
	
		// main loop
		int c = actual; // index for loop through ring storage
		if (++c >= storageSize) c=0; // go one step (don't process actual position)
		do {
			if (newVal <= storageVal[c] && oldOrd > storageOrd[c])
				storageOrd[c]++; // bigger value removed, smaller value added
			else if (newVal > storageVal[c] && oldOrd < storageOrd[c])
				storageOrd[c]--; // smaller value removed, bigger value added
			if (storageOrd[c] == medianPos)
				returnVal = storageVal[c]; // median found
			if (newVal > storageVal[c])
				storageOrd[actual]++; // calculate order of new value
			if (++c >= storageSize) c=0; // go one step in ring storage
		} while (c != actual); // stop at actual position
	}
	// return new median value
	return (returnVal);
}

// dummy arduino sketch, only to show how easy the filter is used:

#define analogPin A0
int analogVal;
int medianVal;

void setup()
{
}

void loop()
{
	// ...
	analogVal = analogRead(analogPin);
	medianVal = median(analogVal);
	// ...
}

Code: Alles auswählen

	int Wert2 = osAnalogInputValues[2];
	Com::printFLN( PSTR( "Wert2: " ), Wert2 );

Code: Alles auswählen

	int Wert2 = osAnalogInputValues[2];
	Com::printFLN( PSTR( "Wert2: " ), Wert2 );

	float feedrate = 100;
  
	if ( Wert2 < 2047 )
	{
		feedrate = 10.0 + (((float)Wert2) * (90.0/2048.0));
		Com::printFLN( PSTR( "feedrate kleiner: " ), feedrate );
	}
	if ( Wert2 > 2048 )
	{
		feedrate = 100.0 + (((float)Wert2-2048) * (300.0/2048.0));
		Com::printFLN( PSTR( "feedrate grosser: " ), feedrate );
	}
  
	Com::printFLN( PSTR( "feedrate: " ), (int)feedrate );
	
	Com::printFLN( PSTR( "Printer::feedrateMultiply: " ), Printer::feedrateMultiply );
	Com::printFLN( PSTR( "Printer::feedrate: " ), Printer::feedrate );
	
	
	Commands::changeFeedrateMultiply((int)feedrate);