POV Bike Wheel: Wie errechne ich immer gleiche Werte?

OP (Firma: http://de8msh.blogspot.com/) Persönliche Seite #1943901
Lesenswert?

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:
1
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,
2
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,
3
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,
4
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};
5
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,
6
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,
7
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,
8
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};
9
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,
10
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,
11
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,
12
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};
13
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,
14
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,
15
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,
16
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};
17
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,
18
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,
19
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,
20
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};
21
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,
22
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,
23
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,
24
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};
25
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,
26
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,
27
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,
28
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};
29

30
int anaus=0;
31
int stelle = 0;
32
int stepcounter=0;
33
int warte=850;               
34
int buttonState = 0;         
35

36
const int buttonPin = 2;     
37

38
void setup() {
39
  pinMode(buttonPin, INPUT);     
40
  pinMode(ledPin, OUTPUT);      
41
 
42
  pinMode(4, OUTPUT);    
43
  pinMode(5, OUTPUT); 
44
  pinMode(6, OUTPUT); 
45
  pinMode(7, OUTPUT); 
46
  pinMode(8, OUTPUT); 
47
  pinMode(9, OUTPUT); 
48
  pinMode(10, OUTPUT); 
49
  
50
//  Serial.begin(9600);
51
}
52

53
void loop(){
54

55
  buttonState = digitalRead(buttonPin);
56

57
  if (buttonState == LOW) {     
58
    anaus=1;
59
  } 
60
  
61
 if (anaus==1)
62
  for (int n=1; n<=2;n++) {
63
  for (int i=stelle; i <= stelle+134; i++){
64

65
  digitalWrite(10, ledChar1[i]);  
66
  digitalWrite(9,  ledChar2[i]);      
67
  digitalWrite(8,  ledChar3[i]);  
68
  digitalWrite(7,  ledChar4[i]);  
69
  digitalWrite(6,  ledChar5[i]);  
70
  digitalWrite(4,  ledChar6[i]);  
71
  digitalWrite(5,  ledChar7[i]);  
72
  
73
  
74
  delayMicroseconds(warte);
75
  }
76
  }
77
 // stepcounter=stepcounter+1;
78
  anaus=0;
79
  digitalWrite(4, LOW);
80
  digitalWrite(5, LOW);
81
  digitalWrite(6, LOW);
82
  digitalWrite(7, LOW);
83
  digitalWrite(8, LOW);
84
  digitalWrite(9, LOW);
85
  digitalWrite(10, LOW);
86

87
     if (stepcounter==2000) {
88
        stepcounter=0;
89
       stelle=stelle+1;
90
     if (stelle>130) {
91
        stelle=0;
92
     }
93

94
     }
95
}
Ich danke Euch für die Hilfe...
#1943916
Lesenswert?

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.
#1944101
Lesenswert?

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.
1
  for (int i=stelle; i <= stelle+134; i++){
2

3
  digitalWrite(10, ledChar1[i]);  
4
  digitalWrite(9,  ledChar2[i]);      
5
  digitalWrite(8,  ledChar3[i]);  
6
  digitalWrite(7,  ledChar4[i]);  
7
  digitalWrite(6,  ledChar5[i]);  
8
  digitalWrite(4,  ledChar6[i]);  
9
  digitalWrite(5,  ledChar7[i]);  
10
  
11
  
12
  delayMicroseconds(warte);
13
  }
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
#1944277
Lesenswert?

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?
OP (Firma: http://de8msh.blogspot.com/) Persönliche Seite #1944765
Lesenswert?

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.

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren