POV Bike Wheel: Wie errechne ich immer gleiche Werte?

[SWL D. (Firma: http://de8msh.blogspot.com/) (de8msh)]

Moinsen,

seit dem ich das Arduino Uno Board habe mache ich vielerlei Blödsinn 
damit.

Z.B.: http://www.youtube.com/watch?v=-ixVwQksBXQ

Nerdish halt :)

Problem: Wie bekomme ich es rein rechnerisch hin, dass die Spalten immer 
annähernd gleich breit sind egal wie schnell sich das Rad dreht, sodass 
die Gesamtlänge der Schrift sich im Grund nicht verändert?

Ich habe lange nachgedacht aber keine Lösung gefunden. Hier der Code:

int ledChar1[]={0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,1,
1,1,1,1,1,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,0,0,
0,0,1,1,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int ledChar2[]={0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,
1,1,1,1,1,1,0,0,0,1,1,0,0,0,0,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,0,0,
0,0,1,1,0,0,0,1,1,1,0,0,0,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int ledChar3[]={1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,0,0,0,0,1,1,0,0,0,1,1,
0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,
0,0,1,1,0,0,0,1,1,1,1,0,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,
1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0};
int ledChar4[]={1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,
0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,
0,0,1,1,0,0,0,1,1,0,1,1,0,1,1,0,0,0,1,1,0,1,1,1,1,1,0,0,0,1,1,1,0,0,0,
1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0};
int ledChar5[]={1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,0,0,0,0,1,1,0,0,0,1,1,
0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,
0,0,1,1,0,0,0,1,1,0,0,1,1,1,1,0,0,0,1,1,0,0,0,0,1,1,0,0,0,1,1,1,0,0,0,
1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0};
int ledChar6[]={0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,1,1,
1,1,1,1,1,1,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,1,
1,1,1,1,0,0,0,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int ledChar7[]={0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,1,
1,1,1,1,1,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,
1,1,1,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

int anaus=0;
int stelle = 0;
int stepcounter=0;
int warte=850;               
int buttonState = 0;         

const int buttonPin = 2;     

void setup() {
  pinMode(buttonPin, INPUT);     
  pinMode(ledPin, OUTPUT);      
 
  pinMode(4, OUTPUT);    
  pinMode(5, OUTPUT); 
  pinMode(6, OUTPUT); 
  pinMode(7, OUTPUT); 
  pinMode(8, OUTPUT); 
  pinMode(9, OUTPUT); 
  pinMode(10, OUTPUT); 
  
//  Serial.begin(9600);
}

void loop(){

  buttonState = digitalRead(buttonPin);

  if (buttonState == LOW) {     
    anaus=1;
  } 
  
 if (anaus==1)
  for (int n=1; n<=2;n++) {
  for (int i=stelle; i <= stelle+134; i++){

  digitalWrite(10, ledChar1[i]);  
  digitalWrite(9,  ledChar2[i]);      
  digitalWrite(8,  ledChar3[i]);  
  digitalWrite(7,  ledChar4[i]);  
  digitalWrite(6,  ledChar5[i]);  
  digitalWrite(4,  ledChar6[i]);  
  digitalWrite(5,  ledChar7[i]);  
  
  
  delayMicroseconds(warte);
  }
  }
 // stepcounter=stepcounter+1;
  anaus=0;
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
  digitalWrite(6, LOW);
  digitalWrite(7, LOW);
  digitalWrite(8, LOW);
  digitalWrite(9, LOW);
  digitalWrite(10, LOW);

     if (stepcounter==2000) {
        stepcounter=0;
       stelle=stelle+1;
     if (stelle>130) {
        stelle=0;
     }

     }
}

Ich danke Euch für die Hilfe...

[Karl H. (kbuchegg)]

Marco De8msh schrieb:

> Problem: Wie bekomme ich es rein rechnerisch hin, dass die Spalten immer
> annähernd gleich breit sind egal wie schnell sich das Rad dreht, sodass
> die Gesamtlänge der Schrift sich im Grund nicht verändert?
>
> Ich habe lange nachgedacht aber keine Lösung gefunden.

Das wird so auch nichts.

Du brauchst zusätzlich noch einen Sensor, der auslöst, wenn der Arduino 
bei jeder Umdrehung immer wieder in der gleichen Position ist.

Damit misst du die Zeit, die eine Umdrehung braucht.
Und mit dieser Zeit kannst du dann ausrechnen, wie lange jede 'Spalte' 
leuchten muss, wenn du in einer kompletten Umdrehung x Spalten 
unterbringen willst.

[SWL D. (Firma: http://de8msh.blogspot.com/) (de8msh)]

Hi,

ich habe einen Sensor: auf der anderen Seite ist ein Magnet:

pinMode(buttonPin, INPUT);

Klar. Sonst würde die Schrift noch nicht mal bei "Null" beginnen. Der 
Linke PAC zeigt sozusagen den Startpunkt.

[Karl H. (kbuchegg)]

Marco De8msh schrieb:
> Hi,
>
> ich habe einen Sensor: auf der anderen Seite ist ein Magnet:
>
> pinMode(buttonPin, INPUT);
>
> Klar. Sonst würde die Schrift noch nicht mal bei "Null" beginnen.

Aber du wertest ihn nicht aus um die Drehzahl des Rades festzustellen.
Du brauchst ein Zeitmanagement!

[Karl H. (kbuchegg)]

Auch wenn du dich bis jetzt erfolgreich davor 'gedrückt' hast, ohne 
Timer und Interrupts kommst du jetzt nicht mehr weiter.
Und die delays ... vergiss sie am besten gleich wieder. Das führt zu 
nichts.

[SWL D. (Firma: http://de8msh.blogspot.com/) (de8msh)]

Ok, dann raus mit den Karten: wo fange ich an?

Ich habe das Board erst sehr sehr kurz. Wie implementiere ich einen 
Timer oder ähnliches? Es steckt der ATMEGA328 drinnen.

Ich hatte auch schon das Gefühl, der hier eine Grenze im Hardcode 
steckt.

[Klaus W. (mfgkw)]

Marco De8msh schrieb:
> Ok, dann raus mit den Karten: wo fange ich an?

Im Tutorial?

[Horst H. (horha)]

Hallo,

man kann natuerlich auch warte anpassen.
Dazu muss man aber die Zeit messen koennen, die eine Umlauf des Rades 
dauert.
Also einen Timer laufen lassen, den passend auslesen ( Interrupt vom 
Schalter )und wieder auf 0 zuruecksetzen.
Wenn sich die Drehzahl verdoppelt halbiert sich warte in etwa.

  for (int i=stelle; i <= stelle+134; i++){

  digitalWrite(10, ledChar1[i]);  
  digitalWrite(9,  ledChar2[i]);      
  digitalWrite(8,  ledChar3[i]);  
  digitalWrite(7,  ledChar4[i]);  
  digitalWrite(6,  ledChar5[i]);  
  digitalWrite(4,  ledChar6[i]);  
  digitalWrite(5,  ledChar7[i]);  
  
  
  delayMicroseconds(warte);
  }

Ein einzelner Schleifendurchlauf dauert zum Beispiel 1000 mueS. Dann 
sind es  150 fuer die Anzeige und 850 fuer das warten.
Bei doppelter Drehzahl muesste ein Durchlauf 500 mueS dauern.Dies 
entspricht einem Wert fuer warte von 350.
Sei warte =850 fuer eine Umlaufzeit T0 (=1/f )  von 1 U/s die Du mit 
deinem Markierungsschalter messen kannst.
Wenn die Drehzahl nun auf T=0.5 U/s steigt ergibt sich fuer warte 350.
Wie zu rechnen?
Dein TGesamt  ist  T*Faktor , dann uebrstreichen die Led immer den 
selben Bogen/Winkel
Dann ist warte ist Tgesamt-150
Der Faktor ist mit den angegebenen Werten 1000 [mueS * s]
Tgesamt = 1000 * 1 U/s
Bei T = 0,5 U/s
Tgesamt = 1000 * 0,5 U/s = 500
Wenn man den Timer geschickt einstellt ( prescale ) , braucht man diesen 
Faktor auch nicht, sondern kann direkt Timerwert-150 rechnen
Oder wie hier:
http://www.freeduino.de/forum/software/fahrradtacho-programmlogik-richtig
ms abfragen

[Sandro S. (sandro)]

Mich wundert, dass das überhaupt funktioniert.
Sehe ich das richtig, dass du sieben Arrays mit etwa 135 Elementen vom 
Datentyp int hast, um Nullen und Einsen zu speichern? Ein int ist zwei 
Byte gross =>  7 x 135 x 2 = 1890 Byte
..und dein µC hat "nur" 2KByte RAM...

Der Datentyp char wäre besser, oder?

[Gerhard (Gast)]

Eindeutig Zeit fürs Tutorial und etwas mehr Hintergrundwissen, sonst 
gewöhnst du dir deinen Programmierstil noch fest an ;)

[SWL D. (Firma: http://de8msh.blogspot.com/) (de8msh)]

Horst Hahn schrieb:
8< 8< 8< 8< 8<
> Tgesamt = 1000 * 0,5 U/s = 500
> Wenn man den Timer geschickt einstellt ( prescale ) , braucht man diesen
> Faktor auch nicht, sondern kann direkt Timerwert-150 rechnen
> Oder wie hier:
> http://www.freeduino.de/forum/software/fahrradtacho-programmlogik-richtig
> ms abfragen

An soetwas hatte ich gedacht. Irgendeine Zeitmessmethode.

[SWL D. (Firma: http://de8msh.blogspot.com/) (de8msh)]

Ok ok, Leute. Ich haue nochmal Grips in die Kiste und melde mich mit 
einem neuen Ansatz. Der Erste klappt ja, aber ist zu starr. Ich kann ja 
auch keinen Strings definieren usw. Also: l8er.