Schieberegister Taster abfrage

[Fabian F. (fabiii9)]

Hallo zusammen,
ich will sehr viele Taster abfragen. (350)
Ist das überhaupt möglich?

Dazu will ich diese Schieberegister nutzen.
http://www.pollin.de/shop/dt/NDk5ODk4OTk-/Bauelemente_Bauteile/Aktive_Bauelemente/IC/Logic_IC.html
Die hab ich schon daheim.

Immer wenn ich eine Taste drücke soll ein Midi-Note_on/off gesendet 
werden.

Ich habe hier schonmal ein Code ohne Schieberegister.
Jetzt will ich den Code so umwandeln, dass ich die Taster über ein 
Schieberegister abfragen kann.

#include <avr/io.h>
#define F_CPU 1000000              // 1 MHz
#define BAUD 31250                // MIDI-Baudrate (31,25kBit)
#include <util/setbaud.h>

#define Taster PD2
#define Taster1 PD3
uint8_t Keydown;
uint8_t Keydown1;

void uart_init(void){
  UBRRH = UBRRH_VALUE;
  UBRRL = UBRRL_VALUE;
  #if USE_2X                  // U2X-Modus erforderlich
  UCSRA |= (1 << U2X);
  #else                    // U2X-Modus nicht erforderlich
  UCSRA &= ~(1 << U2X);
  #endif
  UCSRB |= (1<<TXEN);              // UART TX einschalten
  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1
}

void uart_putc(unsigned char c){
  while (!(UCSRA & (1<<UDRE))){}        // warten bis Senden moeglich
  UDR = c;                  // sende Zeichen
}

void Sendmidinoteon(void){
  uart_putc(145);                // NOTE-ON-Command
  uart_putc(65);                // Tasten-Nummer 69 (A4)
  uart_putc(100);                // Key-Down-Velocity 100
}
void Sendmidinoteoff(void){
  uart_putc(129);                // NOTE-OFF-Command
  uart_putc(65);                // Tasten-Nummer 69 (A4)
  uart_putc(0);                // Release-Velocity 0 (Default)
}
void Sendmidinoteon1(void){
  uart_putc(145);                // NOTE-ON-Command
  uart_putc(69);                // Tasten-Nummer 69 (A4)
  uart_putc(100);                // Key-Down-Velocity 100
}
void Sendmidinoteoff1(void){
  uart_putc(129);                // NOTE-OFF-Command
  uart_putc(69);                // Tasten-Nummer 69 (A4)
  uart_putc(0);                // Release-Velocity 0 (Default)
}

int main(void){
  uart_init();                // Uart initialisieren
  DDRD |= (1<<PD1);              // PD1 Output
  PORTD |= (1<<Taster);            // am Tastereingang Pullup an
  while(1){                  // Endlosschleife
      if(!(PIND & (1<<Taster))){        // wenn Taste gedrueckt
        if( Keydown ){
          Sendmidinoteon();
          Keydown = 0;
        }
      }
      else{                  // wenn Taste nicht gedrueckt
        if( !Keydown ){
          Sendmidinoteoff();
          Keydown = 1;
        }
      }
  }                      // Ende Endlosschleife
}

Ich komm einfach nicht weiter, find auch nichts im Internet was passt.

Vielen Dank schonmal im Vorraus!!!!!


Gruß
Fabi

[Thomas E. (thomase)]

Fabian Müller schrieb:
> Hallo zusammen,
> ich will sehr viele Taster abfragen. (350)
> Ist das überhaupt möglich?
>
> Dazu will ich diese Schieberegister nutzen.
> 
http://www.pollin.de/shop/dt/NDk5ODk4OTk-/Bauelemente_Bauteile/Aktive_Bauelemente/IC/Logic_IC.html
> Die hab ich schon daheim.
>
> Immer wenn ich eine Taste drücke soll ein Midi-Note_on/off gesendet
> werden.
>
> Ich habe hier schonmal ein Code ohne Schieberegister.
> Jetzt will ich den Code so umwandeln, dass ich die Taster über ein
> Schieberegister abfragen kann.

Toll. Du hast einen Code zur Abfrage einer Taste an einem Port, der 
sowieso nicht funktioniert, da der Taster nicht entprellt ist und willst 
den Umbauen?

> Ich komm einfach nicht weiter, find auch nichts im Internet was passt.

Was erwartest du denn? Oder wonach hast du gesucht?
In der Artikelübersicht auf dieser Seite findest du auch einen Artikel 
über Schieberegister.
Die Abfrage eines Schieberegisters ist ganz einfach:
Einmal am Taktpin wackeln, Bit einlesen, Bit in eine Variable schreiben.

Für 350 Taster machst du das 350 Mal. 350 / 8 = 43,75. Also brauchst du 
44 Schieberegister und 44 Byte im Controller, um die Tastendrücke 
bitweise abzuspeichern.

Wenn dein Controller SPI hat, machst du das damit. Dann gehen Wackeln 
und Lesen für jeweils 8 Bit automatisch.

Das machst du ungefähr 50 Mal in der Sekunde. Dazwischen wertest du die 
Tasten, die jetzt im Speicher stehen in aller Ruhe aus. Keine Sorge, das 
schafft dein Controller. Vielleicht solltest du ihn dazu mit 8Mhz takten 
oder auch im Sinne der exakten Midi-Baudrate einen passenden Quarz 
gönnen.

Mit dem Thema "Kaskadierung von Schieberegistern" musst du dich auch 
noch befassen. Aber sieh erstmal zu, daß du eines in deinen Controller 
bekommst.

Alternativ kannst du das auch mit einer 16 * 24 Matrix abfragen. Dann 
brauchst du nur 5 Schieberegister. 3 als Ausgang, 2 als Eingang. Oder 
umgekehrt.

Was für einen Controller hast du denn?

mfg.

[Fabian F. (fabiii9)]

> Toll. Du hast einen Code zur Abfrage einer Taste an einem Port, der
> sowieso nicht funktioniert, da der Taster nicht entprellt ist und willst
> den Umbauen?

Werde noch ein Entprellen einbauen.
Suche nur momentan eine Schieberegisteransteuerung
> Was erwartest du denn? Oder wonach hast du gesucht?
> In der Artikelübersicht auf dieser Seite findest du auch einen Artikel
> über Schieberegister.

Haben nur Codes mit Ausgängen gefunden. Ich brauche aber Eingänge 
(Taster).

> Was für einen Controller hast du denn?
Ich benutze einen Antmega8 momentan.

Vielen Dank für eure Bemühungen
Viele Grüße
Fabi

[Thomas E. (thomase)]

Fabian Müller schrieb:
>> Toll. Du hast einen Code zur Abfrage einer Taste an einem Port, der
>> sowieso nicht funktioniert, da der Taster nicht entprellt ist und willst
>> den Umbauen?
>
> Werde noch ein Entprellen einbauen.
> Suche nur momentan eine Schieberegisteransteuerung
>> Was erwartest du denn? Oder wonach hast du gesucht?
>> In der Artikelübersicht auf dieser Seite findest du auch einen Artikel
>> über Schieberegister.
>
> Haben nur Codes mit Ausgängen gefunden. Ich brauche aber Eingänge
> (Taster).
Du hast nicht die geringste Vorstellung davon, wie man ein 
Schieberegister einliest? Nun gut.
Ich hab dir ja schon geschrieben, wie das geht: Bit einlesen, Schieben, 
Bit einlesen, Schieben...

Das wirst du schon selbst schreiben müssen. Controller-Programmierung 
ist kein Copy & Paste. Beispiele findest du im Artikel über 
Schieberegister.
Ich hatte dir auch geschrieben, daß du entweder 44 Schieberegister oder 
eine 16 x 24 Matrix benötigst. genau genommen reicht 15 X 24. Aber 16 
Bytes einlesen musst du trotzdem. Ich hatte dabei auch gedacht, daß dich 
das genug abschreckt.

Hast du eigentlich irgendeine Vorstellung davon, was du da bauen willst?
350 Tasten. Das sind 3 1/2 PC-Tastaturen.
Das wird eine Schalttafel, bei deren Anblick Captain Kirk blass wird vor 
Neid.

>> Was für einen Controller hast du denn?
> Ich benutze einen Antmega8 momentan.

Was denn auch sonst.

Mit dem Konzept

void Sendmidinoteon(void){
...
void Sendmidinoteoff(void){
...
void Sendmidinoteon1(void){
...
void Sendmidinoteoff1(void){
...
...void Sendmidinoteon349(void){
...
void Sendmidinoteoff349(void){
...

willst du das auswerten?
700 Funktionen. Was denkst du, wann dein Speicher voll ist?
Was du brauchst, ist EINE Funktion, die mit ordentlicher Parametrierung, 
die gewünschte Sequenz schaltet, indem aus Arrays die richtigen Werte in 
Abhängigkeit vom Tastendruck geholt werden.

Wenn du sowas bauen willst, tastest du dich Schritt für Schritt heran.
- Ein Schieberegister einlesen
- Zwei Schieberegister kaskadieren und einlesen

oder sinnvollerweise eine 4 x 4 Matrix am Controllerport
Danach 8 x 8 mit 2 Schieberegistern.
Dann freust du dich über 64 Tasten und fragst dich, ob du wirklich noch 
weitere 286 Tasten anbauen möchtest.

Und nimm einen Atmega328.

mfg.

[Fabian F. (fabiii9)]

Hallo zusammen,
vielen Dank für eure Antworten !!!

Ich brauche deshalb so viele Taster, da ich damit eine Orgel 
midifiziere.

Jetzt werde ich mal das Tutorial durcharbeiten, hoffe cih komm voran, so 
beim ersten Lesen hab ich nicht so wirklich alles verstanden.
Ich hatte gehofft, dass es da irgendein Beispiel irgendwo gibt.

Welchen Atmega bräuchte ich denn, mit dem das realisierbar wäre.

Es werden maximal 5 Taster gleichzeitig gedrückt.

Ich bedanke mich jetzt schon mal.

Gruß
Fabi