wav Dateien: Programieren von Wiedergabe und Aufnahme

[HaWe]

ja, ich habe die Grenzen noch optimiert, nach ein paar Serien sehr ausgefallener random-Waves.
zur Zeit ver 0005-0007.
im Raspy Code mus es ntl als array-Größe SHRT_MAX heißen statt arrlen, und int32_t statt int16_t.

wenn nach dem Rausch-ex vorher/hinterher beim Abhören immer noch alles klar ist, dann kann man jetzt die Grenzen des Signals setzen:

int signalstart=0;
int i=0;
while( (wavbuffer[i]<=baseline+bias) && (i<SHORT_MAX-1) ) ++i;
signalstart=i;

int signalend=SHORT_MAX-1;
i=SHORT_MAX-1;
while( (wavbuffer[i]<=baseline+bias) && (i>signalstart) ) --i;
signalend=i;

jetzt müsten die Grenzen feststehen.
Ich teste es auf dem Arduino aus.
ver 0007c

- - - Aktualisiert - - -

jawohl, klappt!

// ver 0007c

void arrayinit(int16_t * array, int16_t arrlen) {
   char      sbuf[128];
   int16_t   bias, minr, maxr, baseline, 
               maximum, minimum, maxpos, minpos,
               signalstart, signalend;
   uint16_t  i;


   // simulated noisy word-command or signal
   for (i=0; i<arrlen; ++i) {    
     array[i] = 128 + random(11) - 5;  // simulated noise  +/- 5;      
   }
   for (i=33; i<arrlen-101; ++i) {  // simulated word/signal +/- 100
     array[i] = 128 + random(201) - 100;      
   }

   curlf();
   sprintf(sbuf, "arrayinit[0] vorher %d ", array[0] );  
   Serial.println(sbuf);
   lcdprint(sbuf);
  
   // dynamics: min, max 

   maximum = array[0];
   minimum = array[0]; 
 
  
   for(i=0;i<arrlen; ++i)
   {
     if(array[i] > maximum)    {
        maximum = array[i];      
        maxpos = i;
     }
     if(array[i] < minimum)     {
       minimum = array[i];      
       minpos = i;
     }
   }


   // calculate baseline from last 100 array cells:
   // init vars
   baseline=( array[minpos] + array[maxpos] ) / 2;  // init baseline by (min+max)/2
   minr=baseline - 1;
   maxr=baseline + 1;
  
   // auto-adjust:  
   for (i=arrlen-100; i<arrlen; ++i) {    
     // mean baseline
     baseline = round ( ( 0.5*(float)array[i]  + 0.5*(float)baseline )) ;

     // smoothed out max noise
     if (array[i] >= baseline) maxr = round ( ( 0.6*(float)array[i]  + 0.4*(float)maxr )) +1 ;

     // smoothed out min noise
     if (array[i] <= baseline) minr = round ( ( 0.6*(float)array[i]  + 0.4*(float)minr )) -1 ;       
   }
 
   bias = max(baseline-minr, maxr-baseline) +1;  // 
  
   curlf();
   sprintf(sbuf, "baseline %d ", baseline );  
   Serial.println(sbuf);
   lcdprint(sbuf);

   curlf();
   sprintf(sbuf, "bias %d ", bias );  
   Serial.println(sbuf);
   lcdprint(sbuf);


   // noise reduction start/end 
   // drop small noise
   for (i=0; i<arrlen; ++i) {
      if( (array[i]>baseline ) && (array[i] <= baseline + bias)) array[i] = baseline ; // little higher value => drop to baseline
      else
      if( (array[i]<baseline ) && (array[i] >= baseline - bias)) array[i] = baseline ; // little lower value => rise to baseline
   }


   // signalstart, signalend: threshold = bias + (bias/2)   
   signalstart=0;
   i=0;
   while( (array[i]<=baseline + 4*bias/3) && (i<arrlen-1) ) ++i;
   signalstart = i;
   if (i>0) signalstart -=1;   
   signalend=arrlen-1;
   i=arrlen-1;
   while( (array[i]<=baseline + + 4*bias/3) && (i>signalstart) ) --i;
   signalend = i;
   if (i<arrlen-1) signalstart +=1;     
  
   curlf();  
   sprintf(sbuf, "arrayinit[0] nachher %d", array[0] );  
   lcdprint(sbuf);
   Serial.println(sbuf);

   curlf(); _curx_=80;
   sprintf(sbuf, "signalstart %d", signalstart );  
   lcdprint(sbuf);
   Serial.println(sbuf);

   curlf(); _curx_=80;
   sprintf(sbuf, "signalend  %d", signalend );  
   lcdprint(sbuf);
   Serial.println(sbuf); 

}

jetzt bei 7c: Grenzenerkennung funktioniert sogar bei 20% Rauschen sehr gut.
neuestes Bild ganz unten hier im Post:

http://www.mindstormsforum.de/viewto...p=69409#p69409