http://openmoco.org/node/212

Scheint genau für deine Ansprüche schon zu existieren.

Ich meine das so. Dein wert kann maximal vierstellig sein+ einen separierungsoperator wie ein Komma. Du deklarierst und initialisierst ein Char Array mit 5*32 also 160 Zeichen. Dann schreibst du die Werte nacheinander da rein. Am Ende des inneren
Loops gibst du dann den gesamten String/Char-Array aus. Ob das zeit Spart weiß ich ned. Ob das in den Arbeitsspeicher vom arduino passt auch ned, da ich die grenzen meines Arduino noch nicht ausgelotet hab, was das angeht. Da aber die Ausgabe über den Serial Port wahrscheinlich länger dauert als die Werte in ein Array zu legen und sie dann in einem Schwung auszugeben, kann das Zeit sparen. Also sowas in der Art.

Code:

char text[160]
...

void setup(){
for (int i =0;i<160;i++){
text[i]="0";
...
}
...
Loop
..
For...
      For....{
       ...
       Sensorvalue=analogread();
       If(sensorvalue<10){
          itoa(SensorValue,text[i*5+3],10);
        } else  If(sensorvalue<100){
          itoa(SensorValue,text[i*5+2],10);
        } else If(sensorvalue<1000){
          itoa(SensorValue,text[i*5+1],10);
        } else {
          itoa(SensorValue,text[i*5],10);
        }
       If (i!=32){
          text[(i+1)*5-i]=",";
        }
     }
   Serial.println(text);
   for (int i =0;i<160;i++){
   text[i]="0";
   }
}
  

So erhälst du eine Komma separierte Zeile mit allen Werten einer Ebene. Auch wenn es nach viel aussieht, kann des schneller sein wie jedes mal ein Println. Wenn nicht, dann wissen wir,wenigstens, das so rumgespiele mit Char Arrays A..... langsam ist. Ein Versuch ist es Wert.

Ps. Bitte nicht erschlagen, falls es nicht gleich durchkompiliert. Hab grad aufem iPad eingehackt. Es soll dir auch nur die Idee zeigen.

Was mir eingefallen ist. Ich weißtet nicht wie viele Zeichen in einem Println ausgegeben werden können. Aber alle Werte in ein Char Array schreiben und das Char Array auf einmal ausgeben funktioniert schneller Denk ich.oder ebenenweise in das Char Array.

Er zeigt die wirklich nacheinander jeden Messwert an?

Denn du liest am Anfang jedes Zyklus einen Wert aus. Dann schaltest du alle Sensoren durch und das wars. Ohne die auszulesen. Du müsstest genau vor deinem Println den Wert ermitteln IN der FOR-Schleife.

Naja mein Vorschlag war ja auch nicht zu Ernst gemeint. Aber bei seinen Projekten sollte man immer was lernen. Und sowas in einen Algorithmus zu packen ist ne gute Übung für die grauen Zellen.

Ohne jetz genau zu wissen, wie das Signal deiner Gitarre aussieht, würde ich sagen du solltest die Amplitude deiner Schwingung auf 2.5v bringen und so verschieben, damit 2,5v dem nulldurchgang deiner Schwingungen entspricht, um den ADC optimal auszureizen. Ob der 10bit ADC deinen Ansprüchen ausreicht weiß ich nicht. Die Samplerate wird auch nicht die beste sein mit den Arduino Bordmitteln der Speicherbedarf ist bei solchen Sachen auch ned zu unterschätzen. Ich will das Projekt auf keinen Fall schlecht reden, sondern dich bloß auf Dinge hinweisen, die es abzuklären gilt.

http://didier.longueville.free.fr/arduinoos/?p=1134

http://arduino-guitarlooper.blogspot.de/2009/10/introduction-here-how-to-produce-small.html

Ein bisschen Faden ist schon drin, ich würde das, wenn überhaupt, so machen. Aus, halb an , an, halb aus, aus. Sind vier Schritte statt 360 wie in deinem Beispiel und eventuell noch vom arduino zu schaffen. Probieren geht über studieren. könntest auch noch statt halb an, viertel an und Dreiviertel an um ebend nicht linear sondern angenähert sinoid (sagt man des so?). Ich glaube,dass das bei der Frequenz schon zu viel ist.

Um es ein bisschen komplexer zu gestalten

http://de.wikipedia.org/wiki/Gaußsche_Wochentagsformel

So kriegst du den Wochentag, ohne ihn selber einstellen zu müssen, den Rest kriegst du mit if Bedingungen hin.

Richtig coole Idee, ein Fahrrad mit Automatik.

Zur Bestimmung der Formel würde ich die Drehzahlen von Kette und Hinterrad in einer Messreihe aufnehmen, bei unterschiedlichen Situationen, wie bergauf bergab usw. Daraus dann Versuchen Muster zu erkennen und diese dann in einen Algorithmus packen.

Das wird sicher lustig. Viel Glück damit.

Alleine den Antrieb auszulegen und zu konstruieren erfordert schon einiges an Fachwissen. Ich kenn jetz deinen Hintergrund nicht, aber ich würde dir raten dich mal in elektrische Antriebstechnik einzuarbeiten.

Du hast doch bestimmt Anforderungen an die Genauigkeit. Und welche Größe(Höhe) soll der Printer werden, da 30 Kilogramm Kunststoff ne Menge Holz ist.

Eventuell mal in Richtung lineardirektantrieb schauen. Mit ner ausgeklügelten Konstruktion reicht dir vermutlich einer und du kommst in eine gute Genauigkeit.

Edit: eventuell geht sowas mit 400N

http://de.nanotec.com/linearaktuator_L4118.html

Einer davon und 3 gute Führungen, d.h spielfrei und schon läuft die Sache.

Oder 3 kleinere.

Also ich hab mal überschlagsmäßig gerechnet. Deine 30kg entsprechen einem massiven Kunstoffwürfel mit kantenlänge 30 cm, je nach Kunststoff. Wenn man mal grob 10 Kilo für den Tisch veranschlagt. Bleiben immer noch 20 Kilo Kunststoff. Des is immer noch viel. Ich glaube die 30 Kilo sind zu hoch gegriffen.

Ich muss meinen Vorrednern zustimmen. Auch wenn der Arduino einsteigerfreundlich ist, sollte man grundlegende Programierkenntnisse in C haben, um seine Ideen umzusetzen. Die scheinen dir scheinbar vollkommen zu fehlen.

Im winkelmass findest du es im ersten von mir geposteten Code.

Die Werte stimmen, denn sie sind im Bogenmaß. Allerdings würde ich die Berechnung nach der Ermittlung der Quaternionen machen, damit es kein undefiniertes Verhalten im ersten Durchlauf gibt. Dieses komische sind Teile aus der Initialisierung, ich würde am Ende vom setup() noch ein delay(1000) oder so setzen, damit sich der DMP erst einmal setzen kann und werte Produzieren. im nächsten Schritt alle DEBUG_PRINT und DEBUG_PRINTLN aus der Setup werfen, da diese dir nur dazu dienen zu verfolgen, wie der DMP initialisiert wird. Das scheint ja zu funktionieren, da du ja scheinbar Werte erhälst.

hierfür entferne das #define DEBUG relativ weit oben.

am Ende vom loop() noch ein delay(100), damit du die serielle Schnittstelle nicht überlastest.

Deklariere einfach 4 Variablen q0, q1,q2,q3. Weis ihnen die Werte zu. Und übergib sie dann der Prozedur mit &q0, &q1 usw. Dasselbe für die Winkel. Ich hab mich hier für Pointer entschieden,da die Übergabe dann schneller von Statten geht.
Pointer sind Speicheradressen. Für genauere Infos siehe hier.

http://www.peacesoftware.de/ckurs12.html

Das ist mein Code von der Zeitmessung:

Code:

const float pi = 3.14159;
unsigned long ms;

void quaternion2euler(float* q0,float* q1,float* q2, float* q3,float* phi,float* theta,float* psi){ //quaternion2euler(&q0,&q1,&q2,&q3,&phi,&theta,&psi);
 *phi = atan2(2*(*q0 * *q1+*q2 * *q3),1-2*(*q1 * *q1+*q2 * *q2));                          //So sieht der Prozeduraufruf aus
 *theta=asin(2*(*q0 * *q2-*q3 * *q1));                                                       //Einfach die Formeln nachgebildet
 *psi = atan2(2*(*q0 * *q3+*q1 * *q2),1-2*(*q2 * *q2+*q3 * *q3));                          
}

void setup(){
  Serial.begin(9600);
}

void loop(){
 float q0,q1,q2,q3;
 float phi,theta,psi;
 
 q0=0.5;
 q1=0.5;
 q2=0.5;
 q3=0.5;
 ms=millis();
 for(int i=0;i<2000;i++){
 quaternion2euler(&q0,&q1,&q2,&q3,&phi,&theta,&psi);
 }
 Serial.println(millis()-ms);
 Serial.println(phi);
 Serial.println(theta);
 Serial.println(psi);
 delay(10000);
}

Dieses Herstellerbeispiel besteht lediglich aus einer exe Datei, usb-zu-serial treibern für das ARM-Evaluations Board, einer Firmware für dieses im .bin format und zwei PDFs mit einer Benutzeranleitung,wie man diese Demo bedient. Also kein Quellcode, header-dateien oder ähnliches was uns weiterhilft.