wav Dateien: Programieren von Wiedergabe und Aufnahme

[hirnfrei]

Überraschenderweise läuft das ganz gut. Drucker installation war easy, okay der Labeldrucker macht bisschen doof, aber ansonsten bin ich sehr positiv überrascht. Hätte nicht gedacht das man mit dem Teil so gut arbeiten kann!

[HaWe]

ich sach ja, das Linux auf dem Raspi ist echt klasse!

[hirnfrei]

Ich gehe aber mal stark davon aus das sich mein Raspbian was den Desktop angeht nicht mehr viel mit deinem gemeinsam hat ^^^^^

So aber um das Projekt mal weiter zu treiben, hier jetzt mit Plot. Unten ist input, oben ist waveBuffer. Die beiden Linien in waveBuffer zeigen Start und Ende des Signals. Scheint ja ganz gut zu passen.

Einfach Enter drücken dann läuft das Programm weiter.

#include <iostream>
#include <vector>
#include <fstream>
#include <string>

#include <stdio.h>
#include <limits.h>
#include <math.h>

#include <VG/openvg.h>
#include <VG/vgu.h>
#include <fontinfo.h>
#include <shapes.h>

#include "diaSound.hpp"

bool ausgabe = true;

int32_t sStart, sEnde;

void plotten(int32_t *input, int32_t *waveBuffer)
{
    int width, height, i, x = 800;

	float schritt =  x / (float)SHRT_MAX;

	char s[3];

    initWindowSize(20, 20, x, 511);
    init(&width, &height);                  

    Start(width, height);                   
    Background(0, 0, 0);                    
    Fill(0, 255, 255, 1);                   

    StrokeWidth(1.0);

	for(i=0;i<SHRT_MAX;i++)
	{
		Stroke(255, 255, 255, 1.0);
		Line((VGfloat) schritt*i, (VGfloat) input[i], (VGfloat) schritt*(i+1), (VGfloat) input[i+1]);
		Stroke(255, 255, 0, 1.0);
		Line((VGfloat) schritt*i, (VGfloat) waveBuffer[i]+256, (VGfloat) schritt*(i+1), (VGfloat) waveBuffer[i+1]+256);
	}

	Line((VGfloat) schritt*sStart, (VGfloat) 255+256, (VGfloat) schritt*sStart, (VGfloat) 0+256);
	Line((VGfloat) schritt*sEnde, (VGfloat) 255+256, (VGfloat) schritt*sEnde, (VGfloat) 0+256);
	
	
    End();                                  
	
	fgets(s, 2, stdin);
	
	finish();                               


}

void analyse(int32_t *waveBuffer)
{
	int32_t     sbuf[128];
	int32_t     bias, minr, maxr, baseline, 
				signalstart, signalend;

	int32_t maximum = waveBuffer[0];
	int32_t minimum = waveBuffer[0];
	
	int32_t maxpos, minpos;
	
	int32_t i;

	for(i=0;i<SHRT_MAX;i++)
	{
		if(waveBuffer[i] > maximum)
		{
			maximum = waveBuffer[i];
			
			maxpos = i;
		}

		if(waveBuffer[i] < minimum)
		{
			minimum = waveBuffer[i];
			
			minpos = i;
		}
	}
	
	maximum = waveBuffer[0];
	minimum = waveBuffer[0]; 

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


	// calculate baseline from last 100 waveBuffer cells:
	// init vars
	baseline=(waveBuffer[minpos] + waveBuffer[maxpos]) / 2;  // init baseline by (min+max)/2

	minr=baseline - 1;
	maxr=baseline + 1;

	// auto-adjust:  
	for(i=SHRT_MAX-100; i<SHRT_MAX; ++i) 
	{    
	 // mean baseline
	 baseline = round((0.5*(float)waveBuffer[i]  + 0.5*(float)baseline)) ;

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

	 // smoothed out min noise
	 if(waveBuffer[i] <= baseline) minr = round((0.6*(float)waveBuffer[i]  + 0.4*(float)minr)) -1 ;       
	}

	bias = max(baseline-minr, maxr-baseline) +1;  

	// noise reduction start/end 
	// drop small noise

	for(i=0;i<SHRT_MAX;++i) 
	{
	  if((waveBuffer[i]>baseline) && (waveBuffer[i] <= baseline + bias)) waveBuffer[i] = baseline ; // little higher value => drop to baseline
	  else
	  if((waveBuffer[i]<baseline) && (waveBuffer[i] >= baseline - bias)) waveBuffer[i] = baseline ; // little lower value => rise to baseline
	}


	// signalstart, signalend: threshold = bias + (bias/2)   
	signalstart = 0;

	i = 0;

	while((waveBuffer[i]<=baseline + 4 * bias/3) && (i<SHRT_MAX-1)) ++i;

	signalstart = i;

	if(i > 0) signalstart -= 1;   

	signalend=SHRT_MAX-1;

	i=SHRT_MAX-1;

	while((waveBuffer[i]<=baseline + + 4*bias/3) && (i>signalstart)) --i;

	signalend = i;

	if(i<SHRT_MAX-1) signalstart +=1;     

	sStart = signalstart;
	sEnde = signalend;

	if(ausgabe) 
	{
		cout << "Bias: " << bias << endl;
		cout << "Maximal: " << maximum << endl;
		cout << "Minimal: " << minimum << endl;
		cout << "Signalstart: " << signalstart << endl;
		cout << "Signalende: " << signalend << endl;
	}
}

int main(int argc, char *argv[])
{
	fstream datei;
	
	int32_t input[SHRT_MAX], waveBuffer[SHRT_MAX];

	int32_t i;

	if(argc <= 1) audioCapture(input, SHRT_MAX, "plughw:1,0", 1, 12000, 8);
	else
	{
		datei.open(argv[1], ios::in);
		
		for(i=0;i<SHRT_MAX;++i)
		{
			datei >> input[i];
		}
		
		datei.close();
	}
	
	for(i=0;i<SHRT_MAX;i++)
	{
		waveBuffer[i] = input[i] & 0x00ff;
	} 

	analyse(input);

	plotten(input, waveBuffer);

	if(ausgabe)
	{
		uint8_t *wave;
	
		wave = (uint8_t *) malloc(SHRT_MAX+1);
		
		for(i=0;i<SHRT_MAX;i++) wave[i] = waveBuffer[i];
	
		playCaptured(wave, SHRT_MAX, "plughw:1,0", 1, 12000, 8);
	
		free(wave);
	}
	
	return 1;
}

[HaWe]

moin!
schön, dass du weitergekommen bist!

Leider kann ich unmöglich auf meinem Pi z.Zt programmieren, ich habe hier nur einen 7" Miniscreen zur Verfügung -
ich habe die Funktionen daher auf dem PC ein wenig "offline" umgearbeitet.

Zu den Editor-Einrückungen:
könntest du sie bitte immer auf 3 setzen? sonst passen große Funktions- und Loop-Verschachtelungen nicht mehr in 1 Zeile, da zu weit eingerückt.




zur Plot-Funktion - die musste abgeändert werden.

zuerst, dieser ganze Teil zur Initialisierung von OpenVG gehört in eine Funktion mit fester Fenstergröße, z.B. 1024x600

dabei müssen
int _width_=1024, _height_=600;
globale Variablen werden;

Ich habe sie jetzt mit Unterstrichen im Namen definiert, damit sie besser als globale Variablen erkennbar sind.

int _width_=1024, _height_=600;

initOpenVG() {
   initWindowSize(0, 0, _width_, _height_);
   init(&_width_, &_height_);               
   Start(_width_, _height_);                   
   Background(0, 0, 0);                             
   StrokeWidth(1.0);
   WindowOpacity(200);
   WindowClear();
}

initOpenVG() wird in main() oder dem Task aufgerufen, der später für den Screen zuständig ist - in unserem Fall also z.Zt. noch main().


StrokeWidth(1.0);
braucht dann nie mehr neu aufgerufen werden, außer man ändert es
dasselbe gilt für alle anderen Variablen hier in initOpenVG().

finish() gehört als letzter Befehl in die aufrufende Graph-Init-Funktion,
d.h. z.Zt in main() also kurz for exit(0).

Weiter schlage ich vor, in den Funktionen nicht die Bezeichner der globalen Arrays oder anderer Funktionen zu verwenden, das verwirrt -

stattdessen einfach * array, samt Übergabe der Länge.
Denn später ändert sich ja auch noch die Plot-Länge aufs doppelte.


Auch darf die Plot-Funktion immer nur den übergebenen Array plotten, nicht 2 auf einmal.
Deine plot Funktion lautet dann fürs erste:

   // **SNIP**
   for(i=0;i<arrlength;i++)
   {		
      Line((VGfloat) schritt*i, (VGfloat) input[i], (VGfloat) schritt*(i+1), (VGfloat) input[i+1]); // <<<< Fehler ????
   }

Hier verstehe ich aber dein 3. + 4. Argument von Line() nicht: wieso i+1 ?

das Koordinatensystem hat die x-Achse an der Basislinie y0 im Fenster,
die Linien werden also gezeichnet von
xi, y0
nach
xi, (y0 + array[i])

(xi ist der i-te Schritt auf der x-Achse;
der Skalierungsfaktor xscale für die Schritte der xi-Werte kann von plotArray an Hand der array-Länge ausgerechnet werden.


Willst du 2 Koordinatensysteme untereinander malen, kannst du noch eine y0-Postion als Basislinie mit übergeben an plotArray

void plotArray((int32_t *array, int32_t  arrlength, int y0) {

   float xscale=1.0, border=100.0;   // border anpassen !
   xscale =  (float) (arrlength-border)/_width_;  // Ausschöpfung der gesamten openVG-Window-Breite width samt Rand!

   Fill(0, 255, 255, 1);      
   for(i=0;i<arrlength;i++)
   {		
      Line((VGfloat)xscale*i, (VGfloat) y0, (VGfloat)xscale*i, (VGfloat)(y0+input[i]) );
   }
   End();  
}

die Steuerung mit getch() dagegen gehört in die aufrufende Funktion, also analyse, da wo man einen array gerade fertig gerechnet hat.
WindowClear();
muss dann ggf. direkt vor den plotArray-Aufruf.





Auch in analyse solle nicht input oder wavebuffer stehen, sondern nur allgemein array.

analyse wird dann wiederum allgemein von main() oder einer anderen Funktion aufgerufen, ebenfalls mit arrlength als allgemeinen Längenparameter, damit man flexibel bleibt für verschieden lange arrays zum Analysieren:

void analyse(int32_t *array, int32_t  arrlength)  // leicht verändert !!
{
	int32_t     sbuf[128];
	int32_t     bias, minr, maxr, baseline, 
				signalstart, signalend;

	int32_t maximum = array[0];
	int32_t minimum = array[0];	
	int32_t maxpos, minpos;	
	int32_t i;

        char s[3];

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

		if(array[i] < minimum)
		{
			minimum = array[i];
			
			minpos = i;
		}
	}
	
	maximum = array[0];
	minimum = array[0]; 

	for(i=0;i<arrlength; ++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=arrlength-100; i<arrlength; ++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;  

	// noise reduction start/end 
	// drop small noise

	for(i=0;i<arrlength;++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<arrlength-1)) ++i;

	signalstart = i;

	if(i > 0) signalstart -= 1;   

	signalend=arrlength-1;

	i=arrlength-1;

	while((array[i]<=baseline + + 4*bias/3) && (i>signalstart)) --i;

	signalend = i;

	if(i<arrlength-1) signalstart +=1;     

	sStart = signalstart;
	sEnde = signalend;

        WindowClear();
        plotArray(array, arrlength, 30);  // 30 = baseline ordinate   // <<<<<<<<<<<  neu
     
        // >>>>  Tabelle stattdessen ins Graphic window ?

	cout << "Bias: " << bias << endl;
	cout << "Maximal: " << maximum << endl;
	cout << "Minimal: " << minimum << endl;
	cout << "Signalstart: " << signalstart << endl;
	cout << "Signalende: " << signalend << endl;


}

ich habe auch noch openVG-Hilfsfunktionen für Farbe und zur Textausgabe im Grafikfenster eingearbeitet (z.B. zur Beschriftung der Charts oder weiterer Tabellenwete), das kann dann anstelle der obigen initOpenVG komplett folgendermaßen in das Spracherkennungsprogramm übernommen werden:

#include "VG/openvg.h"   
#include "VG/vgu.h"
#include "fontinfo.h"
#include "shapes.h"


//*************************************************************
// openVG
//*************************************************************

// color name constants
#define BLACK     0,   0,   0
#define WHITE   255, 255, 255
#define MAGENTA 255,   0, 255
#define RED     255,   0,   0
#define YELLOW  255, 255,   0
#define LIME      0, 255,   0
#define GREEN     0, 128,   0
#define CYAN      0, 255, 255
#define AQUA    102, 204, 204
#define BLUE      0,   0, 255

int   _width_=1024, _height_=600;
int   _fontsize_ = 10;

#define cls()   WindowClear()


//*************************************************************

inline void lcdprintxy( VGfloat x, VGfloat y, char * buf ) {
   Text( (x+_fontsize_), (y+_fontsize_*1.2), buf, MonoTypeface , _fontsize_);   
}

//*************************************************************

void initOpenVG() {
   initWindowSize(0, 0 , _width_ ,  _height_ );
   init(&_width_, &_height_);
   Start(_width_, _height_);   
   Background(BLACK);
   Stroke(WHITE, 1);                  
   StrokeWidth(1.0);
   Fill(WHITE, 1);            
   WindowOpacity(200);   

   cls();
}

//*************************************************************

void plotArray((int32_t *array, int32_t  arrlength, int y0) {

   float xscale=1.0, border=100.0;   // border anpassen !
   xscale =  (float) (arrlength-border)/_width_;  // Ausschöpfung der gesamten openVG-Window-Breite width samt Rand!

   Fill(0, 255, 255, 1);      
   for(i=0;i<arrlength;i++)
   {		
      Line((VGfloat)xscale*i, (VGfloat) y0, (VGfloat)xscale*i, (VGfloat)(y0+input[i]) );
   }
   End();  
}

//*************************************************************

[hirnfrei]

Hast du irgendwelche weiterführende Pläne mit dem Programm? Du strickst das so munter um das ich langsam das Gefühl kriege das Programm hat längerfristig eine Bedeutung. Ich dachte bisher aber eigentlich es handelt sich um eine Art Versuchsanordnung um die Grundlagen zu erarbeiten.

Was ich jetzt nicht verstehe, ich rufe die Funktion zum Plotten genau einmal auf. Das heisst sie wird nur einmal abgearbeitet. Was macht es da für einen Sinn das Ganze in Main zu arbeiten?

Warum ich i+1 mache? Ich mache eine Linie von Punkt 1, also aktuelle x und y hin zum nächsten Punkt. Also x (bzw. i) +1 für den nächsten Eintrag im Array. Funktioniert ja auch.

Wo liegt das Problem zwei Arrays zu Plotten? Dadurch verändert sich nichts.

Wenn du nicht direkt am Raspi arbeiten kannst? Warum machst du es dann nicht über ssh?

[HaWe]

ich kann kein ssh und werde es auch nie nutzen. Ist so ein Linux Ding, das ich einfach nicht mag.

wir werden plotArray noch öfter brauchen, aber immer nur einfach, eins nach dem anderen, das oben war ja nur der Anfang.

1. Aufruf: array unverändert
2. Aufruf: Rauschen raus und Wort Grenzen ermittelt.
3. Aufruf: Wort herausschneiden und ganz an den Anfang eines neuen Arrays setzen

Probier mal bitte meine Funktion plotArray zu verwenden, deine ist mir völlig unklar, auch wegen der x-Achsen-Skalierung und der gezielten Ausgabe an bestimmten Stellen im Fenster, alleine oder zu mehreren.


Dann geht es weiter wie hier skizziert:

https://www.roboternetz.de/community...l=1#post628055


wir können dann bald die veränderten wav files mit den unveränderten per FFT vergleichen.

- - - Aktualisiert - - -

ps,
eigentlich würde es sogar reichen, nur Punkte zu setzen, keine Linien zu malen:

statt
void Line(VGfloat x1, VGfloat y1, VGfloat x2, VGfloat y2)
jetzt
void Point(VGfloat x, VGfloat y)

ich finde aber keine entsprechende API Funktion.

[hirnfrei]

So ich bin schon am umbauen. Funktioniert soweit. Nur habe ich irgendwie so das Gefühl das man bei deiner Variante nicht so gut sieht wie bei meiner.

Generell, warum ist die dieser von unten nach Oben zeichen Variante lieber wie die die ich genommen hate? Nach meiner Variante wird es doch auch in anderen Soundprogrammen angezeigt.

#include <iostream>
#include <vector>
#include <fstream>
#include <string>

#include <stdio.h>
#include <limits.h>
#include <math.h>

#include <VG/openvg.h>
#include <VG/vgu.h>
#include <fontinfo.h>
#include <shapes.h>

#include "diaSound.hpp"

bool ausgabe = true;

int _width_=1024, _height_=600;

void initOpenVG() 
{
	initWindowSize(0, 0, _width_, _height_);
	init(&_width_, &_height_);               
	Start(_width_, _height_);                   
	Background(0, 0, 0);                             
	StrokeWidth(1.0);
	WindowClear();
}

void plotArray(int32_t *array, int32_t arrlength, int y0) 
{
	float xscale=1.0, border=100.0;
	xscale = (float) (arrlength-border)/_width_;

	int i;

 	Fill(0, 255, 255, 1); 
	Stroke(0, 255, 255, 1);
	     
	for(i=0;i<arrlength;i++)
	{		
		Line((VGfloat)xscale*i, (VGfloat) y0, (VGfloat)xscale*i, (VGfloat)(y0+array[i]));
	}
	End();  
}

void analyse(int32_t *array, int32_t arrlength)
{
	int32_t     sbuf[128];
	int32_t     bias, minr, maxr, baseline, 
				signalstart, signalend;

	int32_t maximum = array[0];
	int32_t minimum = array[0];
	
	int32_t maxpos, minpos;
	
	int32_t i;

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

		if(array[i] < minimum)
		{
			minimum = array[i];
			
			minpos = i;
		}
	}
	
	maximum = array[0];
	minimum = array[0]; 

	for(i=0;i<arrlength; ++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=arrlength-100; i<arrlength; ++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;  

	// noise reduction start/end 
	// drop small noise

	for(i=0;i<arrlength;++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<SHRT_MAX-1)) ++i;

	signalstart = i;

	if(i > 0) signalstart -= 1;   

	signalend=arrlength-1;

	i=arrlength-1;

	while((array[i]<=baseline + + 4*bias/3) && (i>signalstart)) --i;

	signalend = i;

	if(i<arrlength-1) signalstart +=1;     

	if(ausgabe) 
	{
		cout << "Bias: " << bias << endl;
		cout << "Maximal: " << maximum << endl;
		cout << "Minimal: " << minimum << endl;
		cout << "Signalstart: " << signalstart << endl;
		cout << "Signalende: " << signalend << endl;
	}
}

int main(int argc, char *argv[])
{
	fstream datei;
	
	int32_t waveBuffer[SHRT_MAX];

	int32_t i;

	char s[3];

	initOpenVG();

	if(argc <= 1) audioCapture(waveBuffer, SHRT_MAX, "plughw:1,0", 1, 12000, 8);
	else
	{
		datei.open(argv[1], ios::in);
		
		for(i=0;i<SHRT_MAX;++i)
		{
			datei >> waveBuffer[i];
		}
		
		datei.close();
	}
	
	for(i=0;i<SHRT_MAX;i++)
	{
		waveBuffer[i] = waveBuffer[i] & 0x00ff;
	} 
	
	plotArray(waveBuffer, SHRT_MAX, 0);

	analyse(waveBuffer, SHRT_MAX);

	plotArray(waveBuffer, SHRT_MAX, 255);

	if(ausgabe)
	{
		uint8_t *wave;
	
		wave = (uint8_t *) malloc(SHRT_MAX+1);
		
		for(i=0;i<SHRT_MAX;i++) wave[i] = waveBuffer[i];
	
		playCaptured(wave, SHRT_MAX, "plughw:1,0", 1, 12000, 8);
	
		free(wave);
	}

	fgets(s, 2, stdin);

	finish();
	
	return 1;
}

Was ssh angeht. Ja es mag eine Linux Geschichte sein, nur verstehe ich dein Problem damit nicht ganz. Ich nehme mal stark an du startest das compilierte Programm jetzt auch in einem Terminal auf dem Raspi. Dann ist der Unterschied eigentlich super gering. Mittels Putty kannst du eine Verbindung zum Raspi aufbauen- Dabei hast du dann ja einen Terminal der eben nur auf deinem Windows läuft anstatt auf dem Raspi. Nicht einmal auf deinem Windows läuft sondern nur auf diesem angezeigt wird. Wenn du dort dann

geany &

startet geany auf dem Raspi und leitet seine GUI auf dein Windows um. Es läuft also prinzipiell Alles genau so wie auf dem Raspi.Wäre ja zumindest für den Übergang sinnvoll.

[HaWe]

ja, ich glaube ich habe inzwischen auch verstanden, was du machst, du verbindest die Oberkanten der Ausschläge, das gibt eine Art "Obere Umrandungslinie".
Ich habe die Spikes verwendet, weil sie den Hintergrund komplett einfärben und damit kontrastreicher sind (siehe Arduino Plots).

Zum Starten:
nein, ich starte das programm entweder über Geany F5 oder ich starte es im Filemanager (was bei wiringPi nicht geht, wegen sudo-Pflicht) -
oder ich lege einen Link auf den Desktop (Ausführen per sudo).
Solange ich aber damit viel noch rumprogrammiere: immer nur per Geany F5.

Ein Terminal verwende ich nie, diese Un-Toten lasse ich ruhen, und Putty ist für mich Teufelswerk

Ab Mittwoch spätestens habe ich meinen großen Raspi Screen wieder und kann wieder lokal kompilieren

[hirnfrei]

Du willst also lieber die oberen Ausschläge haben?

Für einen C Programmierer bist du aber ziemlich unflexibel .

Ich sage es dir auch nur ungerne aber die Meisten die aktiv programmieren, sei es bei Google oder Microsoft oder wo auch immer, benutzen diese Un-Toten ^^.

[HaWe]

moin!
ich schätze die C-Syntax sehr, weil sie ungeheuer mächtig und perfekt prozedural strukturierbar ist, aber ich bin Hobby-Programmierer und IDEs und USB-p'n'p gewöhnt (wie bei der Arduino IDE oder der Lego BricxCC IDE), und ich würde mich niemals als "typischen" C-Programmierer bezeichnen (C++ beherrsche ich selber gar nicht). Mit der ganzen Linkerei und make, makefile, .so files, logins und IPs will ich nichts zu tun haben, auch nichts mit Terminals (außer automatisch per USB verbinden ohne weitere Einstellungen wie bei Arduino und Serial).
IDE komplett installieren per setup.exe etc.
Programm schreiben in einer IDE
Compilieren per Tastendruck
Hochladen per Tastendruck (falls nötig)
Starten per Doppelklick oder Tastendruck
- so einfach muss Hobbyprogrammieren gehen, das ist mein Level, und genau so funktioniert ja auch Arduino.

was die Anzeige angeht: so wie bei meinem Code-Voschlag oben wäre es eigentlich perfekt, da auch auf kleinen Screens (5", 7") dann skalierbar und gut erkennbar.

void plotArray((int32_t *array, int32_t  arrlength, int y0) {

   float xscale=1.0, border=100.0;   // border anpassen !
   xscale =  (float) (arrlength-border)/_width_;  // Ausschöpfung der gesamten openVG-Window-Breite width samt Rand!

   Fill( CYAN, 1 );      
   for(i=0;i<arrlength;i++)
   {		
      Line((VGfloat)xscale*i, (VGfloat) y0, (VGfloat)xscale*i, (VGfloat)(y0+input[i]) );
   }
   End();  
}