TASTATUR-MATRIX-3X4 analog oder lieber digital ?

Eine Idee für ein neues Projekt ?

Eine sich drehende Erdkugel auf Basis des schwebenden Textes.
Darunter der Spruch: "Allways Windows Booting, since 25 years !".
Am besten vielleicht noch 3D-Brillen tauglich.
Mit der IR-Fernbedienung könnte man dann ja die Umdrehungsgeschwindigkeit und Drehrichtung der Erdkugel beeinflussen !

int wert = analogRead(1);
if(wert == 141){Serial.println("1");}
if(wert >= 105 && wert <= 108){ Serial.println("2");}
if(wert >= 39 && wert <= 41){ Serial.println("3");}
if(wert == 446 || wert == 447){ Serial.println("4");}
if(wert == 369 || wert == 370){ Serial.println("5");}
if(wert == 174){ Serial.println("6");}
if(wert >= 449 && wert <= 451){ Serial.println("7");}
if(wert >= 372 && wert <= 375){ Serial.println("8");}
if(wert == 176 || wert == 177){ Serial.println("9");}
if(wert >= 989 && wert <= 992){ Serial.println("*");}
if(wert == 979){ Serial.println("0");}
if(wert >= 900 && wert <= 920){ Serial.println("#");}

Fast-Arduino, da hast du aber mächtig geändert?
Taste 5: 369 oder 370, Taste 8 schon bei 372? Das ist zu knapp und wird nicht gut gehen...

Halt dich an die Widerstandswerte, dann kannst du die 'if-Abfrage' ruhig großzügiger gestalten,
bei der Tabelle im o.g. Link ist die A/D-Wandlung auf 8bit reduziert, bei dir nicht.
Die kleinste Auflösung bei 10bit ist also 1024/5000mV = 0.2048
für den Toleranzbereich zB der Taste 3 bedeutet das:

max. Wert der Taste 2: 474mV * 0.2048 = 97.0752 = 97 am A/D-Wandler
min. Wert der Taste 3: 588mV * 0.2048 = 120.4224 = 120 am A/D-Wandler

Toleranzbeginn der Taste 3 liegt also dazwischen = (120+97)/2 = ca. 108

max. Wert der Taste 3: 698mV * 0.2048 = 142.9504 = 142 am A/D-Wandler
min. Wert der Taste 4: 930mV * 0.2048 = 190.4640 = 190 am A/D-Wandler

Toleranzende der Taste 3 = (142+190)/2 = ca. 166
Die Taste 3 sollte demnach sicher erkannt werden, wenn der Wert >108 und <166 ist.

Halt dich an die Widerstandswerte, dann kannst du die 'if-Abfrage' ruhig großzügiger gestalten,

...hab ich vorher schon gesagt :wink:

Schaff dir für die Bastelkiste 'ne Hand voll Trimmpotis verschiederster Werte, linear... kann man garnicht genug haben (wenn einem die passenden Widerstände ausgehen)

Was meinst du mit der Erdkugel ? Rotierende Leiterplatten, an den Außenseiten mit LED's bestückst ? ... dann glaub ich weiss, was du meinst. :wink:

Rotierende Leiterplatten, an den Außenseiten mit LED's bestückst ? ... dann glaub ich weiss, was du meinst

POV Globe

Bingo !

Und @ Fast-Arduino, wenn es das ist, dann mach damit ein neues Thema auf :wink:

ja aber das kommmt erst später bei mir ^^also das projekt
erst will ich das mit der tastatur machen

Das Geheimnis liegt wohl darin das man die Led Ausgabegeschwindigkeit an die Winkelgeschwindigkeit der sich drehenden Platine anpassen muss ! Durch die Trägheit der Wahrnehmung wird es dann als komplettes Bild wahrgenommen.

Ich hab so ein RGB-Teil mit USB hier stehen, wahnsinns Effekt. Ich verleihe in primär als "Eyecatcher" für Clubs.

Selber gebaut oder gekauft ? Was für einen Motor benutzt das Teil für die Umdrehung ? Einen Stepper ?

Gekauft, in der Qualität kann man es nicht selbst bauen, besonders da es für kommerzielle Zwecke eingesetzt wird.

also selber baun kann man doch auch wenn man sehr gut darin ist und die passenden sachen hat XD
und wenn man noch ne cnc fräse hat ^^ aber die habe ich leider "noch"nicht ^^

Klar kann man es bauen, nur alleine die Software usw ist halt extrem aufwändig.

Für Privatnutzer ist selberbauen natürlich gut, aber kommerziell - keine Chance mit DIY.

Ich denke mal das dass selberbauen nicht das grosse Problem ist.
Dies liegt vielmehr in der synchronisation zwischen Umdrehungsgeschwindigkeit des Drehtellers und der Ausgabegeschwindigkeit der Ledleiste.

Das einzige was an der Software wirklich aufwendig ist ist herrauszufinden wann sich die Ledleiste wo befindet.
Der Rest dürfte wohl wie eine Ledmatrix funktionieren.

Wenn man die exakte Drehgeschwindigkeit der Motors kennt und man z.b. 100 Zeilen darstellen will. Dann könnte man durch die Winkelgeschwingkeit bestimmen zu welcher Zeit sich der Motor bei welcher der imaginären Zeilen befindet. Und in welchem Zeitintervall man die Ausgabe der Ledleiste aktualisieren muss.

Ich meinte die PC-seitige Software für die RGB-Bildkonvertierung, Zuordnung der Farben auf den nächstliegenden RBG Wert der darstellbar ist, Grössenskalierung, Animationskomprimierung, Upload usw.

Controllerseitig ist das Ansprechen eines genügend grossen Speichers für Bilder und Animationen eher problematisch als die Sync mit Reedkontakt.

Darstellbare Farben:
redtlc = map(redrgb, 0, 255, 0, 4095);
greentlc = map(greenrgb, 0, 255, 0, 4095);
bluetlc = map(bluergb, 0, 255, 0, 4095);

Bild auf dem PC laden und Pixel für Pixel konvertieren.
Von 0 - 255 auf 0 - 4095. Danach vielleicht auf SD-Card speichern und Zeile für Zeile in den Arduino laden.

Mach das mal. Ich denke theoretisch ist es einfach, aber praktisch sehr komplex.

Alleine das Interpolieren der Farbwerte und Pixel bei einem grösseren Einangsbild ist ein Heidenaufwand.

wie teuer ist das verlein ??

Fast-Arduino schrieb:
jetzt habe ich noch die frage kann ich das noch kleiner schreiben?

Kleiner weiß ich nicht, aber anders:
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1251469854/6
der letzte Post ist interessant, es gab nur leider keine Antwort.
Da mein Arduino wieder mit mir spricht hab ich das mal probiert
und es geht auch mit größeren Bereichen, ein kleines Beispiel mit 'Blink':

int var = 1;
void setup() {
  // initialize the digital pin as an output.
  // Pin 13 has an LED connected on most Arduino boards:
  pinMode(13, OUTPUT);
}

void loop() {
  switch (var) {
    case 1 ... 3:
        digitalWrite(13, HIGH);   // set the LED on
        delay(1000);              // wait for a second
        digitalWrite(13, LOW);    // set the LED off
        delay(1000);              // wait for a second
        var = var + 1;
      break;
    case 4 ... 9:
        digitalWrite(13, HIGH);   // set the LED on
        delay(500);              // wait for a second
        digitalWrite(13, LOW);    // set the LED off
        delay(500);              // wait for a second
        var = var + 1;
      break;
    case 10 ... 39:
        digitalWrite(13, HIGH);   // set the LED on
        delay(100);              // wait for a second
        digitalWrite(13, LOW);    // set the LED off
        delay(100);              // wait for a second
        var = var + 1;
      break;
    case 40 ... 99:
        digitalWrite(13, HIGH);   // set the LED on
        delay(50);              // wait for a second
        digitalWrite(13, LOW);    // set the LED off
        delay(50);              // wait for a second
        var = var + 1;
      break;
  }
  digitalWrite(13, LOW);    // set the LED off
}

Jede Blinksequenz läuft ca. 6 Sekunden.
Es wäre eigentlich nicht verkehrt das in die Dokumentation mit aufzunehmen.