Schieberegister: Abfrage von mehreren Tastern

[Fabian F. (fabiii9)]

Hallo liebe Community,

erstmal ein Überblick über mein Projekt:

Ich will eine Orgel midifizieren. In dieser Orgel sind unter jeder 
Tasten ein offener Kontakt.

Jetzt will ich, dass wenn eine Taste gedrückt wird ein Midisignal 
gesendet wird.
Ich habe schonmal eine funktionsfähige Schaltung aufgebaut, wo ich das 
anhand von drei Tastern getestet habe.
Da habe ich die Taster an drei ganz normale Eingänge am Atmega8 
angeschlossen.
Hat super funktioniert.
Mein Code:
Code:

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

#define Taster PD2
uint8_t Keydown;
 
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)
}

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
}

Nachdem ich das aber für ca. 224 Taster machen muss, reichen meine I/O 
Pins natürlich nicht mehr aus.
Tastenmatrix geht auch nicht, da die ja alle auf die gleiche 
"Masse-Stange" tasten.

Also habe ich mich für Schieberegister entschieden.
Ich hätte noch sehr viele MC14021 daheim.
Würde das gerne damit lösen.

Jetzt zu meiner Frage, wie schließ ich das denn eigentlich an??
Empfehlt ihr mir eine SPI Ansteuerung oder eine Software mäsige.
Am Atmega8 wären die SPI Pins frei.

Ich suche jetzt schon seit längerem nach einem Code im Internet.
Habe des Tutorial von mikrocontroller.net über Schieberegister 
durchgearbeitet, doch die verwenden ein anderes Schieberegister. Mächte 
aber meins hernehmen.
Habe mir jetzt mal die Pins angeschaut:

Klicke auf die Grafik für eine größere Ansicht Name: MC14021.jpg Hits: 1 
Größe: 5,8 KB ID: 27673

Wie muss ich es anschließe??
P1-------|
P2-------|
P3-------|
P4-------|- Die 8 Eingänge, wo die Taster hinkommen
P5-------|
P6-------|
P7-------|
P8-------|


C--------?
P/S------?
Ds-------?
Q6-------?
Q7-------?
Q8-------?

VDD------+5V
VSS------Ground

Müsste natürlich dann auch mehrer Schiebereegister in Reihe schalten.

Wäre super nett, wenn mir jemand Links schicken könnte, oder mir einfach 
Tipps geben könnte, Codeschnipsel oder irgendwas.
Vielen lieben Dank für eure Unterstützung!!!

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Wäre super nett, wenn mir jemand Links schicken könnte, oder mir einfach
> Tipps geben könnte, Codeschnipsel oder irgendwas.

Was an deiner gestrigen Gegenüberstellung vom 4021 und dem 74165 ist 
denn jetzt noch unklar?

Mit einer Flanke an P/S (bzw. PL beim 165) werden die internen Speicher 
des IC einmalig von den parallelen Eingängen geladen.
Mit jedem Puls an C (der Clock Leitung) erscheint dann das jeweils 
nächste Bit am seriellen Ausgang (Q7)

Mehr gibt es da eigentlich nicht.

Puls an P/S
Dann in einer Schleife entsprechend viele Pulse an C erzeugen, nach 
jedem Puls den letzten Q7 Ausgang der Schiebregister-Kette abfragen und 
feststellen ob es 0 oder 1 ist und die entsprechende Eintragung in einer 
Variablen des Programms machen.

Kaskadiert werden die Schieberegister, in dem man den jeweiligen 
seriellen Ausgang (Q7) mit dem seriellen Eingang des nächsten 
Schieberegisters verbindet. P/L bzw die Clock Leitung wird an alle 
Bausteine gleich angelegt.

Das ganze ist wirklich sehr einfach.
Steck einen IC in ein Steckbrett rein und probier mal ein bischen mit 
dem IC. LED an den Ausgang, die parallelen Eingänge legst du mit 
Drahtbrücken auf wahlweise 0 oder 5V und mit 2 Tastern (einer am P/L, 
einer am C), denen man einen kleinen Kondensator zur Entprellung 
spendiert (gleich gehen die Taster nicht kaputt) probierst du das 
einfach mal gemächlich durch. Anstelle der Taster kannst du natürlich 
auch deinen AVR anhängen, der die Pulse im 4 Sekunden Takt erzeugt, 
damit du optisch siehst, was sich an der LED am Ausgang tut.

> Ich suche jetzt schon seit längerem nach einem Code im Internet.
In der Zeit hättest du mit einem Testaufbau auf dem Steckbrett und dem 
Datenblatt daneben schon längst selber rausgefunden, wie der 4021 
funktioniert. Hat man das dann verstanden, dann ist die Programmierung 
dessen, was man an den Tastern auf dem Steckbrett gemacht hat eine Sache 
auf 2 Minuten.


Ob man dann das SPI Modul einsetzt, oder doch alles in 'Handarbeit' 
erledigt, ist meiner Meinung nach Geschmackssache.  Speziell in deiner 
Anwendung ist das alles kein Zeitproblem, so dass die paar Takte, die 
eine Handlösung länger braucht, nicht wirklich ins Gewicht fallen. 
Algorithmisch ist das Einlesen vom Schieberegister per Hand sowieso kein 
Problem und der innere Code mit seinen 5 Anweisungen ist auch noch 
überschaubar klein. Ich find immer: Ja, das SPI Modul ist super - es 
schadet aber auch nichts, wenn man das mal ausprogrammiert und so 
versteht, was da eigentlich abgeht. Speziell bei der Fehlersuche ist 
eine Handlösung, die man beliebig verzögern kann, so dass man an den IC 
auch mit einfachen Mitteln was messen kann, klar im Vorteil.

[Stefan F. (Gast)]

Da du die Bits (Tasten) sowieso einzeln auswerten wirst, bietet sich an, 
die Taktung per Software zu machen:

1) Eingänge lesen
2) Takt
3) Erstes Bit verarbeiten
4) Takt
5) zweites Bit verarbeiten
6 ) Takt
usw.

Bei SPI hättest Du eine bytewiese Übertragung, die du in eine Puffer 
übertragen müsstest und dann aus dem Puffer heraus wieder einzelne Bits 
holen müsstest - deutlich aufwändiger.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Puls an P/S
> Dann in einer Schleife entsprechend viele Pulse an C erzeugen, nach
> jedem Puls den letzten Q7 Ausgang der Schiebregister-Kette abfragen und
> feststellen ob es 0 oder 1 ist und die entsprechende Eintragung in einer
> Variablen des Programms machen.

Wobei ich mir nicht sicher bin, ob nach dem P/S Puls nicht bereits das 
erste Bit am Q7 ansteht. Aber das lässt sich ja mit einem 
Steckbrettaufbau schnell verifizieren.

[Karl H. (kbuchegg)]

Stefan us schrieb:
> Da du die Bits (Tasten) sowieso einzeln auswerten wirst, bietet sich an,
> die Taktung per Software zu machen:

Gutes Argument.
Daran hatte ich bei der Modulüberlegung gar nicht gedacht.

[Fabian F. (fabiii9)]

Hallo,

super!!!!!

Vielen Dank für euren so informativen Beiträge.

Werde es jetzt gleich am Steckbrett ausprobieren.

Vielen Dank.

Melde mich dann nochmal.
Gruß

[RomanK (Gast)]

Hallo Fabian,

dein Ehrgeiz in allen Ehren, aber Du bekommst bei dieser Art der Abfrage 
mit einem Schieberegister nur Probleme ( Tastenprellen,Zeitkonstanten, 
usw.). Schaue doch mal auf der Seite www.ucapps.de nach. Dort findest Du 
ein Projekt MIDIO128, wenn ich mich Recht entsinne. Dort sind die 
Probleme alle schon gelöst und es gibt ein Forum für Fragen. Falls Du es 
alleine angehen möchstest dann nutze eine Matrix, die Du Spalten 
und/oder Zeilenweise abfragst. Danach vergleichst Du in einem Bitfeld ob 
die Taste gesetzt war oder nicht und reagierst entsprechend darauf.

Gruss

RomanK

[Possetitjel (Gast)]

Fabian Müller schrieb:
> Nachdem ich das aber für ca. 224 Taster machen muss,
> reichen meine I/O Pins natürlich nicht mehr aus.

Orgel mit 19 Oktaven? Spektakulär. Welche Komponisten
haben denn für Wale und Fledermäuse komponiert? :-)

> Tastenmatrix geht auch nicht, da die ja alle auf die
> gleiche "Masse-Stange" tasten.

???

"UND"-Gatter sind bereits erfunden. Pro Oktave 3 Stück 74HC00;
ein Pull-Up/-Down pro Taste; Decoder für die Auswahl der Oktave.

Im Prinzip gehen auch Latches mit Tristate-Ausgang. Ein Latch
ist für 8 Tasten zuständig; mit zwei 1-aus-16-Decodern und
ein paar Steuerleitungen sollte das Ganze in zwei 8-Bit-Ports
passen. Abgefragt werden somit 28 Gruppen mit je 8 Tasten; das
hat noch den zusätzlichen Charme, dass es etwas fixer geht,
als 224 einzelne Bits seriell hereinzutakten.

[Karl H. (kbuchegg)]

Possetitjel schrieb:
> Fabian Müller schrieb:
>> Nachdem ich das aber für ca. 224 Taster machen muss,
>> reichen meine I/O Pins natürlich nicht mehr aus.
>
> Orgel mit 19 Oktaven? Spektakulär. Welche Komponisten
> haben denn für Wale und Fledermäuse komponiert? :-)

Eine Orgel hat ja auch, wie nennt sich das, ach ja, Züge und Register.
Und je nach Orgel gibt es dann auch mehr als eine Klaviatur, die 
parallel bespielt werden kann.
Wenn das gute Stück anschlagdynamisch ist, dann hat er ausserdem sowieso 
schon mal 2 Kontakte pro Taste, wodurch sich der Umfang sowieso schon 
mal deutlich reduziert.

[Karl H. (kbuchegg)]

> dein Ehrgeiz in allen Ehren, aber Du bekommst bei dieser Art der
> Abfrage mit einem Schieberegister nur Probleme
> (Tastenprellen,Zeitkonstanten, usw.).

Entprellen versteh ich. Aber das das Einholen der Schieberegister ein 
großes Problem sein soll, kann ich mir ehrlich gesagt nicht vorstellen.
224 mal { Pin Hoch, Pin runter, PIN abfragen und Bit setzen, Byte 
schieben }
Über den Daumen sind das bei einem Bit 10 Instruktionen, bei 224 daher 
2240. Bei 1Mhz hat er rund 800-tausend pro Sekunde (und ich geh sogar 
davon aus, dass er mit den 1Mhz noch deutlich höher gehen wird), d.h. 
über den Daumen, kann er alle 224 Tasten pro Sekunde 350 mal abscannen. 
D.h. er hätte einen minimalen Worst Case Zeitversatz von rund 2 
Millisekunden vom Drücken einer Taste, bis der MidiBefehl raus geht (bei 
einer gedrückten Taste).
Hört man das wirklich?

[RomanK (Gast)]

Hallo Karl-Heinz,

theoretisch hast Du recht wenn Du nur die Abfragezeiten addierst. 
Allerdings muss Du noch prüfen in welche Richtung sich die Taste bewegt 
hat, bzw. war sie gedrückt oder nicht. Repetierend ist nicht immer 
gewünscht und da kommt dann die Zeit ins Spiel. Ferner muss den Befehl 
zusammenbauen, sprich der Taste einen Tastaturcode zuweisen, in den 
Buffer schreiben und ausgeben. Ist ganz schön Dampf im Kessel. Ich habe 
so was ähnliches mal mit einer YAMAHA-Orgel bzw. einer alten Korg 
gemacht.

Gruss

Roman

[Fabian F. (fabiii9)]

Hallo zusammen,
erstmal vielen Dank für das Interess am Projekt und den ganzen antworten 
!!

Possetitjel schrieb:
> Orgel mit 19 Oktaven? Spektakulär. Welche Komponisten
> haben denn für Wale und Fledermäuse komponiert? :-)

nein pro Manual (=klaviatur) sind es 64 tasten. Aber ich habe ja mehr 
als ein Manual(=Klaviatur).

RomanK schrieb:
> nutze eine Matrix, die Du Spalten
> und/oder Zeilenweise abfragst. Danach vergleichst Du in einem Bitfeld ob
> die Taste gesetzt war oder nicht und reagierst entsprechend darauf.

Das geht nicht.
Da die alles auf eine Masse schiene schalten.
Ich baue ja nur eine Orgel um und nicht ganz neu.

Karl Heinz schrieb:
> Wenn das gute Stück anschlagdynamisch ist, dann hat er ausserdem sowieso
> schon mal 2 Kontakte pro Taste, wodurch sich der Umfang sowieso schon
> mal deutlich reduziert.

Anschlagdynamik gibt es bei der Orgel nicht.
es gibt nur an oder aus. :-)

Karl Heinz schrieb:
> kann er alle 224 Tasten pro Sekunde 350 mal abscannen.
> D.h. er hätte einen minimalen Worst Case Zeitversatz von rund 2
> Millisekunden vom Drücken einer Taste, bis der MidiBefehl raus geht (bei
> einer gedrückten Taste).

Damit kann ich leben. Des hört niemand.

Also hab jetzt mal auf einem Steckbrett die Schaltung aufgebaut:

Muss nicht die LED an Q8 ?? und nicht Q7 ????????

Also diese LED blinkt immer mal wieder. So ein richtiges System versteh 
ich da noch nicht.
Aber nochmal zum Verständnis.

Wenn ich an den P/S Taster taste sollte doch der Wert übernommen werden, 
der am C Taster zum gleichen Zeitpunkt wo ich Taste anliegt.

D.h
-Drücke Taster an C
-halte ihn gedrückt
-Drücke an Taster P/S
-Jetzt ist im Schieberegister abgefragt worden ob an P1 der Taster 
gedrückt ist.


Doer. stimmt das so???

ICh versteh das schieberegister irgendwie mit den Eingängen noch nicht 
so.

Ausgänge ist klar, aber Eingänge

Wäre sehr dankbar um weiter Tipps.

Vielen Dank
Gruß

[Fabian F. (fabiii9)]

RomanK schrieb:
> Hallo Karl-Heinz,
>
> theoretisch hast Du recht wenn Du nur die Abfragezeiten addierst.
> Allerdings muss Du noch prüfen in welche Richtung sich die Taste bewegt
> hat, bzw. war sie gedrückt oder nicht. Repetierend ist nicht immer
> gewünscht und da kommt dann die Zeit ins Spiel. Ferner muss den Befehl
> zusammenbauen, sprich der Taste einen Tastaturcode zuweisen, in den
> Buffer schreiben und ausgeben. Ist ganz schön Dampf im Kessel. Ich habe
> so was ähnliches mal mit einer YAMAHA-Orgel bzw. einer alten Korg
> gemacht.
>
> Gruss
>
> Roman

Meint ihr es funktioniert oder meint ihr es wird mit schieberegistern 
nicht funktionieren in der Zeit.

Ich muss doch eigentlich nur so ein paar Tastger abfragen, das kann doch 
nicht sol lange dauern. :-) :-) :-)

[Karl H. (kbuchegg)]

RomanK schrieb:

Gleich vorweg: du hast mir da Erfahrung voraus, ich hab noch nie etwas 
in dieser Richtung gemacht.

> theoretisch hast Du recht wenn Du nur die Abfragezeiten addierst.

Kannst du ein Limit angeben, wie oft man mindestens die Klaviatur pro 
Sekunde abfragen muss, damit sich das für den Spieler noch nicht 
bemerkbar macht?

Würde mich mal persönlich interessieren.

> Allerdings muss Du noch prüfen in welche Richtung sich die Taste bewegt
> hat, bzw. war sie gedrückt oder nicht.

Gut, das ist jetzt nicht so wild. Wenn ich richtig gerechnet habe, dann 
kommen vom Schieberegister 28 Bytes rein. Veränderung feststellen ist 
ein XOR mit dem vorhergehenden Wert, ob gedrückt oder nicht gedrückt ist 
ein AND. Zum Schluss einmal alle 28 Bytes in einen Old-Buffer 
umkopieren.

> Repetierend ist nicht immer
> gewünscht und da kommt dann die Zeit ins Spiel.

Den Teil versteh ich nicht. Was meinst du mit repetierend?
Für jede veränderte Klaviaturtaste wird doch ein Not-On bzw. Note-Off 
verschickt. Oder denke ich da zu naiv?

> Ferner muss den Befehl
> zusammenbauen, sprich der Taste einen Tastaturcode zuweisen

Auch nicht wild. Im einfachsten Fall ein Arrayzugriff.

> in den
> Buffer schreiben und ausgeben.

UART-Ausgabe per Interrupt. Zb. die Fleury Routinen beherrschen das 
perfekt.


Aus meiner Sicht ist der Dreh und Angelpunkt: wieviele Klaviatur-Scans 
benötigt man tatsächlich pro Sekunde, damit es sich am Keyboard beim 
Spielen nicht 'zäh' anfühlt. Da hab ich keine Erfahrungswerte.

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Also hab jetzt mal auf einem Steckbrett die Schaltung aufgebaut:
>
> Muss nicht die LED an Q8 ?? und nicht Q7 ????????

Ja Q8.

(Ich hab in alter C Manier bei 0 angefangen zu zählen. 
IC-Ausgangs-Bezeichnungen werden aber oft beginnend mit 1 nummeriert. 
Das höchstwertige Bit halt)

[RomanK (Gast)]

Hallo Karl-Heinz,

du musst ja nicht nur mit einem XOR feststellen ob in einem Byte ein Bit 
gesetzt ist, du musst ja auch das Löschen eines Bits ermitteln. Dann den 
Tastaturcode holen 3 Bytes in den Buffer und dann nächste Tasteninfo 
holen.
Es können bis zu max. 11 Tasten bewegt werden. Es gibt noch einen 
Running Status der es etwas einfacher macht, aber das führt jetzt zu 
weit. Im allgemeinen gelten > 5 ms als störend, denn es geht ja nicht 
nur um das Senden von Daten, sondern diese werden auch empfangen und 
verarbeitet. Bei 31,25 kbaud ein ganz schönes Gehampel.

Gruss

Roman

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Also diese LED blinkt immer mal wieder. So ein richtiges System versteh
> ich da noch nicht.
> Aber nochmal zum Verständnis.
>
> Wenn ich an den P/S Taster taste sollte doch der Wert übernommen werden,
> der am C Taster zum gleichen Zeitpunkt wo ich Taste anliegt.

?

Wenn ich dein Bild richtig deute, dann hast du die Eingänge P1 bis P8 
alle mit Masse verbunden. Also alles 0

Drückst du P/S, denn werden diese 8 Stück 0-er in die Schiebekette 
übernommen.

Ich denke das erste Bit müsste jetzt bereits an Q8 sichtbar sein. Das 
ist das Bit, das vom P8 stammt. Da kann ich mich auch irren, aber das 
kann man ja ausprobieren, wie das wirklich ist.

Drückst du einmal auf C, dann bewegt sich die Schiebekette um eine 
Stelle weiter. Jetzt ist das Bit von P7 am Ausgang (Q8) sichbar.
Drückst du nochmal auf C, dann geht es wieder um 1 Stufe weiter. Jetzt 
ist das Bit, das von P6 stammt am Ausgang sichtbar, etc. etc.

> D.h
> -Drücke Taster an C
> -halte ihn gedrückt
> -Drücke an Taster P/S
> -Jetzt ist im Schieberegister abgefragt worden ob an P1 der Taster
> gedrückt ist.

falsch.
zuerst machst du die Übernahme der Werte von den Px Leitungen ins 
Schieberegister, das macht der P/S Eingang.

Nachdem dann die Werte im Schieberegister sind, wandern die einzelnen 
Bits im Gänsemarsch aus dem Q8 Ausgang raus. Eines nach dem anderen und 
jeweils um 1 Schritt weiter, wenn du einmal auf C drückst.

[Possetitjel (Gast)]

Fabian Müller schrieb:
> Das geht nicht.

Da es offenbar noch nicht angekommen ist:

DOCH !
DAS GEHT !

> Da die alles auf eine Masse schiene schalten.

LOGIKGATTER SIND BEREITS ERFUNDEN WORDEN !

> Ich baue ja nur eine Orgel um und nicht ganz neu.

[Karl H. (kbuchegg)]

RomanK schrieb:
> Hallo Karl-Heinz,
>
> du musst ja nicht nur mit einem XOR feststellen ob in einem Byte ein Bit
> gesetzt ist, du musst ja auch das Löschen eines Bits ermitteln.

Ja sag ich doch.
Mit einem XOR stell ich fest, ob es eine Veränderung gab und mit einem 
AND Stelle ich fest, ob diese Veränderung ein Niederdrücken oder ein 
Loslassen war.

  // 28 Bytes von den Schieberegistern nach newValue einlesen
  ...

  // Nach Veränderungen scannen und entsprechende Midi
  // Note-On bzw. Note-Off Messages generieren

  uint8_t keyCode = 0;
  for( uint8_t i = 0; i < 28; i++ )
  {
    uint8_t changed = oldValue[i] ^ newValue[i];
    uint8_t pressed = newValue[i];

    for( uint8_t bit = 0; bit < 8; ++bit )
    {
      if( changed & 0x80 )
      {
        if( pressed & 0x80 )
          SendNoteOn( midiNote[keyCode] );
        else
          SendNoteOff( midiNote[keyCode] );
      }
      keyCode++;
      changed <<= 1;
      pressed <<= 1;
    }

    oldValue[i] = newValue[i];
  }

SendNoteOn bzw. SendNoteOff benutzen die Fleury Lib, die erst mal alles 
in einen Buffer stellt und per Interrupt ausgibt. Das garantiert mir, 
das ich nicht auf die UART warten muss, sondern in der Zwischenzeit 
weiter scannen kann.

geh ich da jetzt zu naiv vor?

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> jeweils um 1 Schritt weiter, wenn du einmal auf C drückst.


Ich wollte es eigentlich noch dazu schreiben, habs aber dann vergessen.

Vorausstzung ist natürlich, dass deine Taster entprellt sind. Mit ein 
paar Krokoklemmen, mit denen du einen Draht antippst, bist du von 
'entprellter Kontakt' weit entfernt. D.h. deinem Gefühl nach erzeugst du 
nur 1 Puls, tatsächlich sind es aber mehrere kurze.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Mit einem XOR stell ich fest, ob es eine Veränderung gab und mit einem
> AND

Das mit dem AND war natürlich Quatsch. Das brauch ich in dieser Form gar 
nicht. Die Info ob gedrückt oder nicht liegt ja bereits vor. Die brauch 
ich mir nur holen.

[RomanK (Gast)]

Hallo Karl-Heinz,

natürlich geht es und es ist schön zu sehen das die Aufgabe Deinen 
Ehrgeiz heraufbeschworen hat. Bloss keyCode sollte ein Array von 
mindestens 64 Bytes sein. Die einzelnen Tastaturen werden sogn. 
MIDI-Kanälen zugeordnet, so dass durch die Überdeckung der Tasten eine 
geringe Anzahl Tastaturcodes generiert werden muss. Den Rest macht der 
Channel. Hier kann man das Pedal noch eine Oktave rauf oder runter 
rechnen. Ebenso die Manuale, und schon hätte man eine Transposer mit 
eingebaut. Es lief bei mir mit einem 20MHz Quarz und war auf die 1MHz 
Tastaturroutine ausgerichtet. Wenn ich mich recht erinnere entsprachen 
die 20 Ticks einer Codierung. Ist halt schon lange her. Lass mich der 
Versuchung mich da wieder reinzuknien widerstehen. Macht zwar Spass, ist 
aber hoffnungslos langsam und veraltet. Gibt es da nicht schon den 
Nachfolger USB-MIDI? Soll eine höhere Übertragungsgeschwindigkeit 
erlauben.

Gruss

Roman

P.S.: Spiele lieber wieder analog.

[Karl H. (kbuchegg)]

RomanK schrieb:

> mindestens 64 Bytes sein. Die einzelnen Tastaturen werden sogn.
> MIDI-Kanälen zugeordnet, so dass durch die Überdeckung der Tasten eine
> geringe Anzahl Tastaturcodes generiert werden muss. Den Rest macht der
> Channel. Hier kann man das Pedal noch eine Oktave rauf oder runter
> rechnen. Ebenso die Manuale, und schon hätte man eine Transposer mit
> eingebaut.


:-)
Also geh ich doch noch ein bischen zu naiv an die Sache ran.
Du hast natürlich recht. All diese Dinge hab ich nicht bedacht.

> es ist schön zu sehen das die Aufgabe Deinen Ehrgeiz heraufbeschworen hat

Es ist halt etwas, an dem ich mich noch nie versucht habe. Und das macht 
die Sache dann doppelt so interessant. Wer weiß wozu man die Technik mal 
brauchen kann. Momentan jedenfalls hab ich keinen Bedarf dafür.

Obwohl. hmm ich hab noch wo eine alte Klaviatur mit 3 Oktaven rumliegen. 
Jetzt bräucht ich nur noch entsprechende Kontaktfedern.

[RomanK (Gast)]

Hallo Karl-Heinz,

deine Antwort verursacht ein Kribbel in meinen Fingern, das lieber nicht 
da sein sollte. Aber nimm keine Kontaktfedern, sondern wie jemand weiter 
oben vorgeschlagen hat optische Elemente. Hat den Vorteil das wenn Du 
schnell genug abfragst, kannst Du auch noch die Dynamik mit welcher die 
Taste gedrückt wurde errechnen. Nennt sich Velocity und kann das dritte 
Byte im Tastaturcode werden.

Viel Spass

Roman

[Fabian F. (fabiii9)]

Karl Heinz schrieb:
> Obwohl. hmm ich hab noch wo eine alte Klaviatur mit 3 Oktaven rumliegen.
> Jetzt bräucht ich nur noch entsprechende Kontaktfedern.

Nehm Hall Sensoren !
Mit das beste was sich dazu eignet.
Werden auch in allen professionellen Tastaturen verbaut.

[Karl H. (kbuchegg)]

RomanK schrieb:

> da sein sollte. Aber nimm keine Kontaktfedern, sondern wie jemand weiter
> oben vorgeschlagen hat optische Elemente.

Hmm. Das muss ich überlesen haben. Aber die Idee ist an sich nicht 
schlecht.

Meine Mechanik hab ich so um 1982 gekauft. Da waren wohl noch 
Federkontakte aus, ich glaube, Silberstahl üblich, die auf eine 
gemeinsame Schiene geschaltet haben (Monophon). Die hab ich damals nicht 
gekriegt und wenn wären sie wohl auch damals zu teuer für mich gewesen. 
Also hab ich einfach Stahlfedern genommen. Und genau so gut hat das dann 
auch funktioniert. Mit genügend Kontaktspray konnte ich damals auch die 
Kontaktprobleme durch Korrosion zumindest eine Zeitlang im Zaum halten.
Das war damals, als ich mir in den Kopf gesetzt hatte, den ChoroSynth 
von Elektor(?) zu bauen.


Da ich allerdings nie richtig Spielen gelernt habe, werde ich es dann 
wohl doch eher lassen. Zuviel Aufwand für nichts.
Aber interessant wärs schon. Zumal es heute auf dem PC ein paar 
Programme gibt, die einen schönen analogen Synthi nachbilden :-) Das 
digitale Zeugs mit den ganzen vordefinierten Instrumenten interessiert 
mich weniger. Gegen eine gut eingestellte VCF hat sowas niemals nicht 
eine Chance.

[Wilhelm F. (Gast)]

224 Taster, das sind dann wohl 28 Stück vom 4021. Sollte aber gehen. 
Wenn man 200ns pro Takt rechnet, dauert die komplette Einlesung 45µs. 
Eine Entprellung sollte auch noch gehen. Ich glaube, daß das sogar noch 
ein fast 40 Jahre oller µC 8048 alles locker schaffen kann. Vielleicht 
auch noch die Ausgabe, auch wenn er keinen UART hat.

Die Pins P/S und Clock für den 4021 kann man evtl. noch mit einem Buffer 
verstärken, weil ja jeweils 28 parallel geschaltet sind. Das gibt eine 
Pinkapazität von bestimmt um die 300pF. Oder langsamer takten. Aber erst 
mal ohne versuchen, ob es nicht auch so geht.

[Fabian F. (fabiii9)]

Was ist jetzt eigentlich so der letzte Stand?

Geht es mit Schieberegistern oder eher nicht ???

ICh würde mich jetz dann mal dran machen einen Code zu schreiben für 
erstmal 8 Tasten mit dem MC14021.

Hoffe ich bekomm es hin.

Vielen Dank für eure Engagement !!


Danke für den Tipp:

Wilhelm F. schrieb:
> Die Pins P/S und Clock für den 4021 kann man evtl. noch mit einem Buffer
> verstärken, weil ja jeweils 28 parallel geschaltet sind. Das gibt eine
> Pinkapazität von bestimmt um die 300pF. Oder langsamer takten. Aber erst
> mal ohne versuchen, ob es nicht auch so geht.

Wie meint ihr sollte ich entprellen??
per Software oder Hardware??

[Karl H. (kbuchegg)]

Fabian Müller schrieb:
> Was ist jetzt eigentlich so der letzte Stand?
>
> Geht es mit Schieberegistern oder eher nicht ???

Du hast mehrere Manuals erwähnt.
Wieviele?


Hintergrund:
Niemand sagt, dass alle Manuals über einen einzigen Pin eingelesen 
werden müssen. Man könnte auch jedem Manual eine eigene 
Schieberegisterkette spendieren.
Alle Schieberegisterketten teilen sich die P/S und die C Leitung. Die 
Daten landen allerdings am µC auf einem anderen Pin, sodass man alle 
Manuals parallel einlesen könnte.

Bei 2 Manuals halbiert das bereits die zum Einlesen benötigte Zeit. Bei 
3 drittelt es diese Zeit, etc.

Ich denke, das würde schon mal helfen aus diesem Codeteil den meisten 
Stress rauszunehmen.

Auf jeden Fall würde ich aber mal darüber nachdenken, die 1Mhz 
µC-Taktfrequenz in die Höhe zu schrauben. Es gibt kaum einen Grund das 
nicht zu tun, aber jede Menge Gründe es zu tun.

> Wie meint ihr sollte ich entprellen??
> per Software oder Hardware??

Erst mal würde ich Software versuchen, wenn überhaupt. Wenn das nichts 
wird, kann man immer noch auf Hardware gehen.
Wobei, wenn Roman Recht hat, und eine Zykluszeit von deutlich unter 5ms 
anzusteben ist, dann könnte sich das zu einem Problem ausarten.


Ich weiß, dass ich mich jetzt weit aus dem Fenster lehne. Aus dem Bauch 
raus würde ich sagen: Das ganze Projekt ist auch mit Schieberegistern 
machbar.

[Wilhelm F. (Gast)]

Fabian Müller schrieb:

> Was ist jetzt eigentlich so der letzte Stand?
>
> Geht es mit Schieberegistern oder eher nicht ???
>
> ICh würde mich jetz dann mal dran machen einen Code zu schreiben für
> erstmal 8 Tasten mit dem MC14021.
>
> Hoffe ich bekomm es hin.
>
> Vielen Dank für eure Engagement !!

Ja natürlich geht das, mach hinne! Ich habe in einem alten Buch hier 
zwar nur ein Beispiel für 16 Tasten mit zwei Bausteinen 4021 liegen, 
also die Bausteinkaskadierung geht definitiv!

Ich schau mal nach, dieses Beispiel zu finden. Dann kann ich hier noch 
weiter behilflich sein.

> Danke für den Tipp:
>
> Wilhelm F. schrieb:
>> Die Pins P/S und Clock für den 4021 kann man evtl. noch mit einem Buffer
>> verstärken, weil ja jeweils 28 parallel geschaltet sind. Das gibt eine
>> Pinkapazität von bestimmt um die 300pF. Oder langsamer takten. Aber erst
>> mal ohne versuchen, ob es nicht auch so geht.
>
> Wie meint ihr sollte ich entprellen??
> per Software oder Hardware??

Versuchs per Software. Hardware hat doch wieder einiges an 
Bauteileaufwand.

[Fabian F. (fabiii9)]

Karl Heinz schrieb:
> Du hast mehrere Manuals erwähnt.
> Wieviele?
>
> Hintergrund:
> Niemand sagt, dass alle Manuals über einen einzigen Pin eingelesen
> werden müssen. Man könnte auch jedem Manual eine eigene
> Schieberegisterkette spendieren.
> Alle Schieberegisterketten teilen sich die P/S und die C Leitung. Die
> Daten landen allerdings am µC auf einem anderen Pin, sodass man alle
> Manuals parallel einlesen könnte.
>
> Bei 2 Manuals halbiert das bereits die zum Einlesen benötigte Zeit. Bei
> 3 drittelt es diese Zeit, etc.

Hallo,
erstmal wieder vielen Dank für euer Interesse und eure Tipps!!

Ich hätte 3 Manuale (z.Zt nur 2, soll aber auf 3 erweiterbar sein): Pro 
Manual 60 Tasten
+ Pedal mit 30 Tasten.

Ich bräuchte doch dann insgesamt 8 I/os. Das wäre kein Problem.
Sind noch genügend frei.
Dann müsste ich immer nur 8 Schieberegister maximal hintereinandern 
schalten.

Bin gerade am Coden. Komm nur gerade nicht so wirklich weiter, wie ich 
den "Algorithmus" schreiben muss, dass bei jeder Taste die gedrückt wird 
auch der passende Ton gesendet wird...
Ich hoffe ich habs bald.


Vielen Dank!!!!
Viele Grüße

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Ich bräuchte doch dann insgesamt 8 I/os. Das wäre kein Problem.
> Sind noch genügend frei.
> Dann müsste ich immer nur 8 Schieberegister maximal hintereinandern
> schalten.

Das ist doch schon was.
8 anstelle von 28. Das drückt schon mal gewaltig.

> Bin gerade am Coden. Komm nur gerade nicht so wirklich weiter, wie ich
> den "Algorithmus" schreiben muss, dass bei jeder Taste die gedrückt wird
> auch der passende Ton gesendet wird...

Ähm.
Kleiner Tip. Ich hab da weiter oben schon was vorbereitet :-)

> Ich hoffe ich habs bald.

Hast du denn dein Schieberegister schon korrekt ausgelesen?

Als ersten Test würde ich den hier machen:
in einer Schleife 1 Schieberegister auslesen und die gelesenen BIts an 
einem Port mit 8 LED wieder ausgeben.
Die LED müssen dann dem folgen, was ich an den Schieberegister EIngängen 
P1 bis P8 mit Drahtbrücken oder Tastern einstelle.

Warum mache ich das so?
WEil das Ausgeben von Bits auf einen Port trivial ist. Da kann nichts 
schief gehen, das ist so einfach, dass ich das aus dem Stand hinkriege. 
Wenn ich die entsprechenden Bits gleich beim ersten Test per Midi 
versende und dann tut sich nichts im Synthesizer, dann weiß ich wieder 
nicht, wo das Problem liegt: bei den Tasten, beim Schieberegister, bei 
der Umsewtzung in Midi, bei der UART, im Synthesizer. Das sind mir zu 
viele Fehlermöglichkeiten. Ich bin auf lange Sicht immer am Besten 
gefahren, wenn ich die ersten Tests so einfach wie nur irgendwie 
möglich, mit möglichst wenigen potentiellen Fehlermöglichkeiten, 
gestaltet habe. Noch einfacher als 8 LED an einem Port geht nun mal 
nicht.
Und - Nebeneffekt - das ging in der Entwicklung auch in Summe immer am 
schnellsten :-)

[Fabian F. (fabiii9)]

Hallo zusammen,
zerbreche mir gerade den Kopf :-).

Ich habe hier meinen Code, den ich bis jetzt habe.

/*
 * Schieberegister_Orgel.c
 *
 * Created: 05.03.2014 16:47:06
 *  Author: Fabian
 */ 


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

#define P_S PB0;
#define C PB1;
#define Q7 PB2;

uint8_t Keydown;

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 Schieberegister_einlesen(void){
  uint8_t var=0;
  uint8_t durch;
  DDRB = (1 << PB0); 
  
  
  PORTB = (1<<PB0);
  PORTB = (0<<PB0);
  
  while(8){
    PORTB = (1<<PB1);
    PORTB = (0<<PB1);
    if(!(PINB & (1<<PB2))){        // wenn gedrÜckt
      var[durch]=1;
    }
    else{
      var[durch]=0;
    }
    durch+1;
  }
  
  
  
}
int main(void)
{
    uint8_t keyCode = 0;
    uint8_t changed = 0;
    uint8_t pressed =0 ;
        if( changed & 0x80 ){
          if( pressed & 0x80 ){
          uart_putc(145);          //Note ON
          uart_putc(keyCode);        //Tastennummer
          uart_putc(0);          //Velocity
        }          
          else{
          uart_putc(129);          //Note OFF
          uart_putc(keyCode);        //Tastennummer
          uart_putc(0);          //Velocity
        }        
     
      }
}

Der Teil bei der Funktion Schieberegister_einlesen kommt natürlich ein 
Fehler, wegen den zwei Variablen die da hintereinandern in eckigen 
Klammern stehen.
Weiß nur gerade einfach nicht weiter, wie ich das löse.

Jemand Rat??

Vielen Dank für eure so intensive Mithilfe und mitdiskussion.
Wenn das Projekt fertig ist, habe ich vor eine Dokumentation zu 
schreiben und diese hier im Forum zu veröffentlichen, damit auch jeder 
was davon hat.

Gruß

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Fehler, wegen den zwei Variablen die da hintereinandern in eckigen
> Klammern stehen.
> Weiß nur gerade einfach nicht weiter, wie ich das löse.
>
> Jemand Rat??

Ähm
Was sagt dir der Begriff 'Array'?

Im Ernst. Du solltest erst mal deine Programmiersprache auch richtig 
erlernen, ehe du dich an Projekte wagst. Ein Klempner-Azubi wird auch 
erst auf die Menschheit losgelassen, wenn er mit ein wenig mehr Wekrzeug 
als nur mit einem Hammer umgehen kann.

[Karl H. (kbuchegg)]

>   PORTB = (1<<PB0);
>  PORTB = (0<<PB0);

So werden keine einzelnen Portbits gesetzt.
Gehe zurück an den Anfang und mach erst mal deine ersten Übungen mit 
gezieltem LED schalten.

So wies sich dein Code jetzt präsentiert, hat der Anfang nur deshalb 
funktioniert, weil du ihn wo abgeschrieben hast. Das ganze Elend 
offenbart sich erst jetzt. Es könnte sein, dass das alles noch 
mindestens 3 Schuhnummern zu groß für dich ist.

Es reicht eben nicht, nur den Wunsch zu haben etwas zu machen. Man muss 
auch zumindest die Grundlagen dazu verstehen.

[Fabian F. (fabiii9)]

Hallo,
ja ihr habt ja recht.

Aber ich will einfach meine Orgel midifiziert bekommen.
Habe den Schweller schon hinbekommen und einzele Kontrolltasten auch.
Mir fehlen halt nur noch die Abfragen von den Klaviaturen und dem Pedal.

Ich bin eigentlich einfach jemand der gern Orgel spielt.
Habe halt eine Johannus daheim, damals gebruacht gekauft, aber der Klang 
nervt mich einfach.
Jetzt war ich so guter Dinge, weil ich lauter Codes und Beispiel im 
INternet gefunden habe und hab mich riesig gefreut und stundenlang 
getüftelt und gesurft, oder war hier im Forum unterwegs. UNd jetzt 
fehlen mir halt nur noch die Tasten. Ich habe das gesamte Hardware-Zeugs 
gekauft und habe das jetzt daheim.

Kann mir nicht irgendjemand, für den das ein Kinderspiel ist so ein 
Schieberegister abzufragen, mir einen Code schreiben.
Wenn ich das hinbekomme, gebe ich eine Ruhe. Ich verspreche es :-).
Ich werde mich dann auch mit der Mateire Mikroocntroller beschäftigen 
und c so richtig erlernen.

Wäre halt super wenn mir jemand den Code schreiben könnte. Habe diese 
Woche Ferien und Zeit sowas zu machen.
Bin noch Schüler. Deswegen wollte ich es auch selber bauen, um Geld zu 
sparen.

Ich würde dann, für jedes Manual eine eigene Schieberegisterkette 
machen.

Vielen Dank !!
Gruß

[Fabian F. (fabiii9)]

Wer mir den Code schreibt, bekommt dann auch ein paar Orgel Mp3s :)

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Kann mir nicht irgendjemand, für den das ein Kinderspiel ist so ein
> Schieberegister abzufragen, mir einen Code schreiben.

An welche Pins hast du denn welchen Anschluss vom SR angeschlossen?

[Fabian F. (fabiii9)]

P_S: PB0;
C: PB1;
Q7: PB2;

Und die Midiausgabe: siehe Anhang.


Vielen Dank !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Gruß
Fabi

[Karl H. (kbuchegg)]

ok.
ich brauch erst mal einen Vortest, um zu checken ob das Schieberegister 
(SR) so funktioniert, wie ich mir das vorstelle.

Dazu würde ich 2, besser 3 LED an den Pins PD5, PD6 und PD7 brauchen.
LED mit Vorwiderstand (220 Ohm, ist nicht kritisch, ich bin nicht auf 
Helligkeit aus) gegen Vcc verschalten.

      µC-Pin   --------|<-----R----- Vcc (+5V)

                      LED    220

Ebenfalls vorbereiten kannst du dir einen Schaltmechanismus für die 
Schieberegister Eingänge P1 bis P8.
Du hast oben mal erwähnt, dass deine Klaviaturmechanik so funktioniert, 
dass beim Tastendrücken ein Kontakt nach Masse hergestellt wird. D.h. 
wir werden einen Pullup Widerstand pro Taste brauchen. Wenn die schon im 
Keyboard vorhanden sind, umso besser.
Grundsätzlich funktioniert dann jede einzelne Taste so

                         Vcc (+5V)
                          |
                          R
                          |
      SR-Pin   -----------+
                          |
                           /  Taste
                          |
                          |
                         GND

wenn im Keyboard bereits Pullups eingebaut sind, dann benutzen wir die. 
Wenn nicht, dann muss jede Taste einen kriegen. Ich würde mal, in 
Ermangelung anderer Vorschläge einen Wert rund um 10k vorschlagen. 10k 
wohl auch deshalb, weil ich in meinem Bauteilsortiment eine eigene 
Schublade mit 10k Widerständen nur für diesen Zweck habe :-) Der 
tatsächliche Wert ist nicht kritisch. Von 4k7 bis 56k dürfte so ziemlich 
alles gehen. Also nimm was du hast. Wichtig ist, dass der grundsätzliche 
Aufbau mit Taster nach Masse und Pullup gegeben ist.
Wenn du die Keyboard Tasten noch nicht benutzen willst, weil das noch 
unhandlich ist, dann geht das auch mit eine Stückchen Draht, welches du 
per Hand nach GND verbindest. Das ist zum jetzigen Zeitpunkt noch nicht 
kritisch.


OK. Ich setz mich mal drann das Testprogramm zu schreiben. MIDI kommt 
später. Erst mal wollen wir wissen, ob das Schieberegister so 
funktioniert, wie wir uns das vorstellen. Dazu brauch ich die LED als 
Ausgabemechanismus.

Das was ein Mega8. Richtig?

[Fabian F. (fabiii9)]

Karl Heinz schrieb:
> 3 LED an den Pins PD5, PD6 und PD7 brauchen.

Das ist kein problem, hab ich daheim.

Karl Heinz schrieb:
> Wenn die schon im
> Keyboard vorhanden sind, umso besser.

Nein sind noch nicht im Keyboard verbaut.
Schließe halt einfach einen 10kOhm Widerstand an, so wie im Schaltbild.

Karl Heinz schrieb:
> Mega8. Richtig?

Ja richtig.

Das wäre echt super, wenn du das machen würdest.

Vielen Dank !!!!!

Gruß
Fabi

[Karl H. (kbuchegg)]

OK.
Erstes Testprogramm

#include <avr/io.h>

// Schieberegister MC14021
#define SR_DDR   DDRB
#define SR_PORT  PORTB
#define SR_PIN   PINB
#define SR_PS    PB0
#define SR_C     PB1
#define SR_DATA  PB2

#define SET_BIT(p,b)  p |= (1<<(b))
#define CLR_BIT(p,b)  p &= ~(1<<(b))
#define IS_SET(p,b)   (p & (1<<(b)))

uint8_t fetchByte()
{
  uint8_t i;
  uint8_t Result;

  SET_BIT( SR_PORT, SR_PS );
  CLR_BIT( SR_PORT, SR_PS );

  Result = 0;
  for( i = 0; i < 8; i++ )
  {
    Result <<= 1;

    if( IS_SET( SR_PIN, SR_DATA ) )
      Result |= 0x01;

    SET_BIT( SR_PORT, SR_C );
    CLR_BIT( SR_PORT, SR_C );
  }

  return Result;
}

int main(void)
{
  uint8_t Byte;

  SR_DDR |= (1<<SR_PS) | (1<<SR_C);

  DDRD |= (1<<PD5) | (1<<PD6) | (1<<PD7);

  while(1)
  {
    Byte = fetchByte();

    if( IS_SET( Byte, 5 ) )
      SET_BIT( PORTD, PD5);
    else
      CLR_BIT( PORTD, PD5 );

    if( IS_SET( Byte, 6 ) )
      SET_BIT( PORTD, PD6);
    else
      CLR_BIT( PORTD, PD6 );

    if( IS_SET( Byte, 7 ) )
      SET_BIT( PORTD, PD7);
    else
      CLR_BIT( PORTD, PD7 );
  }
}

die Erwartungshaltung ist:
die 3 Led korrespondieren mit den Eingängen P6, P7 und P8 vom 
Schieberegister. Je nachdem ob dort der Taster geschlossen ist oder 
nicht, muss die zugehörige LED ein oder ausgehen.

Bitte teste mir das mal, damit ich sicher bin, das das SR korrekt 
ausgelesen wird. Wichtig ist, dass alle 3 LED auf ihren jeweiligen 
Eigang reagieren und das auch die korrekte LED jeweils reagiert.
Die Zuordnung ist

P6  -> Led an PD5
P7  -> Led an PD6
P8  -> Led an PD7

[Karl H. (kbuchegg)]

Gibts ein Problem?
Wenns nicht funktioniert, dann sags ruhig. So ganz 100% werd ich nämlich 
aus dem ON-Semiconductor Datenblatt auch nicht schlau, wie das mit dem 
parallel mode bzw. serial mode gemeint ist. Daher ja auch der Vortest.

[Fabian F. (fabiii9)]

Hallo,
super vielen Dank.
Werde es gleich ausprobieren.

Habe es gestern nicht mehr geschafft.


Gruß
Fabi

Und danke schon mal

[Fabian F. (fabiii9)]

Hallo,
also irgendwie passieren ein paar sehr komische Dinge.

Wenn ich nur irgendeinen Eingang vom Schieberegister mit meiner Hand 
anfasse, leuchtet die LED. Ohne dass irgendetwas verbunden ist. Habe 
mehrere Bilder angehängt, wo man es sehen kann, was passiert wenn ich 
was anfasse, und was passiert, wenn ich einen Eingang mit Masse 
verbinde.

Ich glaube eigentlich schon, dass ich alles richtig verbunden habe.

Habe auch ein anderes Schieberegister geteste, an dem lags nicht.

Was läuft da falsch ??

Vielen dan k für deine so intensiven bemühungen
Gruß

[Fabian F. (fabiii9)]

ich muss doch das schieberegister mit dem atmega8 so verbinden:

SR_PS    PB0
SR_C     PB1
SR_DATA  Q8

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Wenn ich nur irgendeinen Eingang vom Schieberegister mit meiner Hand
> anfasse, leuchtet die LED.

Ja, das ist normal.

> Ohne dass irgendetwas verbunden ist.

So einfach ist die Sache nicht.
Der Eingang ist mit dir verbunden. Und du fungierst als Antenne. Du 
fängst dir jede elektromagnetische Welle in deiner Umgebung ein und 
gibst das Potential an den IC weiter. Und elektromagn. Wellen gibt es in 
unserer Umgebung zur Genüge.

Daher ja auch: man lässt einen Eingang nicht einfach offen. Daher auch 
die Pullup-Widerstände, die für ein definiertes Potential sorgen, auch 
wenn nichts angeschlossen ist. Ohne Pullup, und ich kann auf deinem 
Photo keine erkennen, ist das was du siehst genau das was ich ungefähr 
erwarten würde.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> wenn nichts angeschlossen ist. Ohne Pullup, und ich kann auf deinem
> Photo keine erkennen, ist das was du siehst genau das was ich ungefähr
> erwarten würde.

Ich seh da 3 Widerstände auf deinem Photo. Sollen das die Pullups sein? 
Wenn ja, dann sind sie falsch verschaltet.

Die Widerstände müssen nach Vcc führen, sonst ist es kein Pullup. Der 
Schalttaster stellt dann eine Verbindung vom Widerstand nach Masse her

[Karl H. (kbuchegg)]

So (Bild) muss das verschaltet werden.
Die grünen Leitungen, die zum SR führen sind ok.

[Fabian F. (fabiii9)]

Hallo,
oh ja stimmt, ich hatte den Pullup falsch angeschlossen.
Sorry!! Peinlich. Du hast mir ja sogar den Anschlussplan geschickt.


So jetzt funktioniert deine Schaltung so indirekt.

Wenn ich nicht taste, dann leuchten alle LEDs.
Wenn ich Taste, geht genau die aus die ich auch Taste.

Ist also genau falschrum.
 Doer?

Oder ist es so gewollt??


Vielen Dank.

Echt super Testschaltung.
Kann dadbei sicher viel von dir oleren.

Gruß
Fabi

[Karl H. (kbuchegg)]

Fabian Müller schrieb:
> ich muss doch das schieberegister mit dem atmega8 so verbinden:
>
> SR_PS    PB0
> SR_C     PB1
> SR_DATA  Q8


Ja. das ist das was du mir angegeben hast.

Das die LED leuchtet, ist ja an und für sich schon ein gutes Zeichen :-)
Denn es bedeutet ja, dass der µC zumindest mal aus dem Schieberegister 
was kriegt.

Jetzt will ich nur noch wissen, ob er auch das korrekte kriegt.
Lass mich auf dem Photo mal identifizeren, welcher LED welche ist, 
welcher Eingang vom SR welcher ist, und dann schaun wir mal, ob die 
Zuordnung stimmt oder ob die um 1 Bit verschoben ist.

[Fabian F. (fabiii9)]

Karl Heinz schrieb:
> So (Bild) muss das verschaltet werden.
> Die grünen Leitungen, die zum SR führen sind ok.

So hab ich es jetzt auch gemacht. :-)

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Wenn ich nicht taste, dann leuchten alle LEDs.
> Wenn ich Taste, geht genau die aus die ich auch Taste.

super. passt also

> Ist also genau falschrum.
>  Doer?

bin mir nicht sicher. Ist auf dem Photo schwer zu erkennen aber ich 
denke du hast ja auch die LED nicht so gesteckt, wie ich es dir vorgegen 
habe. Deine LED führen nach Masse und nicht nach Vcc. Und dann ist das 
Beobachtete wieder genau richtig.

> Oder ist es so gewollt??

Hängt davon ab, wie du die LED verbaut hast.

[Fabian F. (fabiii9)]

SR---Ausgang

P6 -> PD5
P7 -> PD6
P8 -> PD7

So sind die Zuordnungen

[Fabian F. (fabiii9)]

Karl Heinz schrieb:
> bin mir nicht sicher. Ist auf dem Photo schwer zu erkennen aber ich
> denke du hast ja auch die LED nicht so gesteckt, wie ich es dir vorgegen
> habe. Deine LED führen nach Masse und nicht nach Vcc. Und dann ist das
> Beobachtete wieder genau richtig.

Das war der Fehler.

Entschuldige!!!!


Also dann funktioniert es jetzt wunderfbar.

Danke schon mal

[Karl H. (kbuchegg)]

Ist aber egal, lass dich jetzt nicht vom Ein/Aus der LED irritieren. 
Wichtig ist, dass die LED reagieren und das können sie nur, wenn das 
Schieberegister korrekt ausgelesen wird.

Das bei einem nicht gedrückten Taster ein 1-Bit vom Schieberegister 
kommt, das ist sowieso klar. Das kann gar nicht anders sein, denn wenn 
der Taster nicht gedrückt ist, dann zieht der Pullup ja den Eingang auf 
1.

[Karl H. (kbuchegg)]

Gut.
Einen Moment bitte.
Ich richte mir hier mal schnell die UMgebung ein, um aus dem 
Testprogramm die nächste Stufe zu bauen. Du kannst in der Zwischenzeit 
den ganzen UART Teil wieder anklemmen, der dann zu einem anderen Midi 
Eingang führt.

:-)
Wir gehen gleich in die vollen.
Als nächstes verschicken wir mal Note-On und Note-Off Befehle, wenn sich 
was am Eingang tut.
Ich denke das ist vertretbar. Die UART hast du ja schon in Betrieb 
gehabt und da jetzt noch eine Zwischenstufe einzuführen, mit der man an 
den LED sieht, dass der Programmteil korrekt ist, der eine Veränderung 
feststellt - den kriegen wir auch so blind hin. Das ist eine 
Standardtechnik.

Aber lass mich erst mal was zu Essen holen :-)

[Karl H. (kbuchegg)]

ok.

Probier das mal

#define F_CPU 1000000              // 1 MHz
#define BAUD 31250                // MIDI-Baudrate (31,25kBit)

#include <avr/io.h>
#include <util/setbaud.h>

// Schieberegister MC14021
#define SR_DDR   DDRB
#define SR_PORT  PORTB
#define SR_PIN   PINB
#define SR_PS    PB0
#define SR_C     PB1
#define SR_DATA  PB2

#define SET_BIT(p,b)  p |= (1<<(b))
#define CLR_BIT(p,b)  p &= ~(1<<(b))
#define IS_SET(p,b)   (p & (1<<(b)))

// Midi Kommandos
#define NOTE_ON    145
#define NOTE_OFF   129

// Die Tonhöhen 'Noten', so wie MIDI sie definiert
//                            C   D   E   F   G   A   H   C
const uint8_t midiNote[] = { 48, 50, 52, 53, 55, 57, 59, 60 }; 

uint8_t fetchByte()
{
  uint8_t i;
  uint8_t Result;

  SET_BIT( SR_PORT, SR_PS );
  CLR_BIT( SR_PORT, SR_PS );

  Result = 0;
  for( i = 0; i < 8; i++ )
  {
    Result <<= 1;

    if( IS_SET( SR_PIN, SR_DATA ) )
      Result |= 0x01;

    SET_BIT( SR_PORT, SR_C );
    CLR_BIT( SR_PORT, SR_C );
  }

  return Result;
}

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( uint8_t c )
{
  while (!(UCSRA & (1<<UDRE)))     // warten bis Senden moeglich
    ;

  UDR = c;
}

void SendNoteOn( uint8_t note )
{
  uart_putc( NOTE_ON );
  uart_putc( note );
  uart_putc( 100);
}

void SendNoteOff( uint8_t note )
{
  uart_putc( NOTE_OFF );
  uart_putc( note );
  uart_putc( 0 );
}

int main(void)
{
  uint8_t prevKeys;
  uint8_t nowKeys;
  uint8_t changed, pressed;
  uint8_t keyCode;

  SR_DDR |= (1<<SR_PS) | (1<<SR_C);
  uart_init();

  prevKeys = fetchByte();

  while(1)
  {
    nowKeys = fetchByte();

    keyCode = 0;
    changed = nowKeys ^ prevKeys;
    pressed = nowKeys;

    if( changed != 0x00 )
    {
      for( uint8_t bit = 0; bit < 8; ++bit )
      {
        if( changed & 0x80 )
        {
          if( !(pressed & 0x80) )
            SendNoteOn( midiNote[keyCode] );
          else
            SendNoteOff( midiNote[keyCode] );
        }
        keyCode++;
        changed <<= 1;
        pressed <<= 1;
      }

      prevKeys = nowKeys;
    }
  }
}

mit ein bischen Glück solltest du damit eigentlich schon mit deinen 8 
improvisierten Tastern 'Alle meine Entchen' spielen können.

[Fabian F. (fabiii9)]

Danke!! ich probier es gleichg aus!

[Fabian F. (fabiii9)]

Hallo,
so habe es jetzt gerade getestet.
Funktioniert gar nicht schlecht.

ein kleiner fehler ist drin.
Mir ist aber unklar, wie der Zustande kommt.

Wenn ich an P3 Taste wird einmal ein Note-On Befehl von der Taste A3 und 
F3 gesendet, und wenn ich loslasse wird ein NOteoff-Befehl von A3 und F3 
gesendet.

Da sind irgendwie zwei Tasten ?????

sonst passt alles.

Hier die Midievents, die kommen, wenn ich jeden einmal anklick.

 TIMESTAMP IN PORT STATUS DATA1 DATA2 CHAN NOTE EVENT               
    300424  1  --    145    60   100    2  C  4 Note On               
    300485  1  --    129    60     0    2  C  4 Note Off   
           
    304765  1  --    145    59   100    2  B  3 Note On               
    304846  1  --    129    59     0    2  B  3 Note Off  
            
    308431  1  --    145    57   100    2  A  3 Note On               
    308432  1  --    145    53   100    2  F  3 Note On        
    308468  1  --    129    57     0    2  A  3 Note Off              
    308469  1  --    129    53     0    2  F  3 Note Off  
            
    314077  1  --    145    55   100    2  G  3 Note On               
    314078  1  --    129    55     0    2  G  3 Note Off    
     
    315087  1  --    145    53   100    2  F  3 Note On               
    315089  1  --    129    53     0    2  F  3 Note Off              
            
    316316  1  --    145    52   100    2  E  3 Note On               
    316325  1  --    129    52     0    2  E  3 Note Off              
         
    317389  1  --    145    50   100    2  D  3 Note On               
    317408  1  --    129    50     0    2  D  3 Note Off          
          
    318334  1  --    145    48   100    2  C  3 Note On               
    318353  1  --    129    48     0    2  C  3 Note Off,

Sind die Tasten jetzt eigentlich entprellt???

Vielen Dank.
Super Arbeit!!!

Gruß
Fabi

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Wenn ich an P3 Taste wird einmal ein Note-On Befehl von der Taste A3 und
> F3 gesendet, und wenn ich loslasse wird ein NOteoff-Befehl von A3 und F3
> gesendet.
>
> Da sind irgendwie zwei Tasten ?????

Irgendeine Chance, dass da sich wo im Hardware Aufbau eine Verbindung 
eingeschlichen hat?

> Sind die Tasten jetzt eigentlich entprellt???

Nein.

[Karl H. (kbuchegg)]

Verpass den Schieberegister mal einen 100nF Blockkondensator zwischen 
Vcc und GND.
(Und dem Mega auch)

[Fabian F. (fabiii9)]

Hallo,
es war tatsächlich ein hardware Fehler.

P5 war an Q7 angeschlossen.

Hab ich vorhin nicht gesehen.
Man verrutscht da so schnell, auf dem steckbrett.

Karl Heinz schrieb:
> Verpass den Schieberegister mal einen 100nF Blockkondensator zwischen
> Vcc und GND.
> (Und dem Mega auch)

Habe ich nicht daheim. Ginge auch ein 5 V Spannungsregler? (L7805CV)

Vielen Dank
Gruß
Fabi

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Habe ich nicht daheim.

Dann bestell gleich welche.
Du wirst für JEDES Digital-IC (mindestens) einen 100nF Kerko brauchen.

> Ginge auch ein 5 V Spannungsregler? (L7805CV)

Nein.
Der Kondensator hat die Aufgabe, kleinste Spannungsspitzen 
auszugleichen. Das kann ein 7805 nicht.

[Karl H. (kbuchegg)]

OK. Also 1 Schieberegister geht schon mal.

Dann bauen wir jetzt mal 2 rein.
Du machst die Hardware, ich das Programm.

Das zweite SR wird so angeschlossen, dass P/S und C auf P/S bzw. C vom 
ersten gesteckt werden. Q8 vom 2.ten wird mit DS vom ersten verbunden.

Wieder: an die Eingänge Taster samt Pullup-Widerstand.

[Fabian F. (fabiii9)]

Ach einen ganz normalen Kerko?

Den hab ich natürlich daheim.

Blockkondensator: Das habe ich nicht verstanden.
Wieder was dazu gelern :-)

Den hätte ich:
http://www.reichelt.de/Scheiben/KERKO-100N/3//index.html?ACTION=3&GROUPID=3169&ARTICLE=9265&SEARCH=KERKO%20100N&SHOW=1&OFFSET=16&;
Der müsste ja passen.


Und wie soll der angeschlossen werden.
Einfach die VCC Leitung vom schieberegister und dem AVR auftrennen und 
dazwischen einen KERKO ??


Vielen Dank
Gruß
Fabi

[Fabian F. (fabiii9)]

Karl Heinz schrieb:
> OK. Also 1 Schieberegister geht schon mal.
>
> Dann bauen wir jetzt mal 2 rein.
> Du machst die Hardware, ich das Programm.
>
> Das zweite SR wird so angeschlossen, dass P/S und C auf P/S bzw. C vom
> ersten gesteckt werden. Q8 vom 2.ten wird mit DS vom ersten verbunden.
>
> Wieder: an die Eingänge Taster samt Pullup-Widerstand.

ok. super danke !!!!


Gruß
Fabi

[Karl H. (kbuchegg)]

Ich habs jetzt nicht grossartig im Simulator abgeklopft

#define F_CPU 1000000              // 1 MHz
#define BAUD 31250                // MIDI-Baudrate (31,25kBit)

#include <avr/io.h>
#include <util/setbaud.h>

#define NR_SR    2

// Schieberegister MC14021
#define SR_DDR   DDRB
#define SR_PORT  PORTB
#define SR_PIN   PINB
#define SR_PS    PB0
#define SR_C     PB1
#define SR_DATA  PB2

#define SET_BIT(p,b)  p |= (1<<(b))
#define CLR_BIT(p,b)  p &= ~(1<<(b))
#define IS_SET(p,b)   (p & (1<<(b)))

// Midi Kommandos
#define NOTE_ON    145
#define NOTE_OFF   129

// Die Tonhöhen 'Noten', so wie MIDI sie definiert
//
const uint8_t midiNote[8*NR_SR] =
    {
//     C  C#   D  D#   E   F  F#   G
      48, 49, 50, 51, 52, 53, 54, 55,
//    G#   A   b   H   C  C#   D  D#
      56, 57, 58, 59, 60, 61, 62, 63
    }; 

uint8_t fetchByte()
{
  uint8_t Result = 0;
  for( uint8_t i = 0; i < 8; i++ )
  {
    Result <<= 1;

    if( IS_SET( SR_PIN, SR_DATA ) )
      Result |= 0x01;

    SET_BIT( SR_PORT, SR_C );
    CLR_BIT( SR_PORT, SR_C );
  }

  return Result;
}

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( uint8_t c )
{
  while (!(UCSRA & (1<<UDRE)))     // warten bis Senden moeglich
    ;

  UDR = c;
}

void SendNoteOn( uint8_t note )
{
  uart_putc( NOTE_ON );
  uart_putc( note );
  uart_putc( 100);
}

void SendNoteOff( uint8_t note )
{
  uart_putc( NOTE_OFF );
  uart_putc( note );
  uart_putc( 0 );
}

void scanKeys( uint8_t* keys )
{
  SET_BIT( SR_PORT, SR_PS );
  CLR_BIT( SR_PORT, SR_PS );

  for( uint8_t i = 0; i < NR_SR; i++ )
    keys[i] = fetchByte();
}

int main(void)
{
  uint8_t prevKeys[NR_SR];
  uint8_t nowKeys[NR_SR];
  uint8_t changed, pressed;
  uint8_t keyCode;

  SR_DDR |= (1<<SR_PS) | (1<<SR_C);
  uart_init();

  scanKeys( prevKeys );

  while(1)
  {
    scanKeys( nowKeys );

    keyCode = 0;
    for( uint8_t i = 0; i < NR_SR; i++ )
    {
      changed = nowKeys[i] ^ prevKeys[i];
      pressed = nowKeys[i];

      prevKeys[i] = nowKeys[i];

      if( changed != 0x00 )
      {
        for( uint8_t bit = 0; bit < 8; ++bit )
        {
          if( changed & 0x80 )
          {
            if( !(pressed & 0x80) )
              SendNoteOn( midiNote[keyCode] );
            else
              SendNoteOff( midiNote[keyCode] );
          }
          keyCode++;
          changed <<= 1;
          pressed <<= 1;
        }
      }
      else
        keyCode += 8;
    }
  }
}

Achte bitte auch darauf, ob die Notenwerte an den Eingängen eine schöne 
Reihe bilden. D.h. an P1 vom jeweiligen SR sollte der tiefste Ton jedes 
Schieberegisters sein. (Im Prinzip ist es wurscht, aber beim endgültigen 
Verkabeln ist es einfacher, wenn es da ein einfaches System gibt)

Bin mir nicht sicher, aber ich denke das ist jetzt genau verkehrt rum.

[Karl H. (kbuchegg)]

Wenn das letzte Programm funktioniert, dann kannst du weitere 
Schieberegister anschliessen.
Alles was du tun musst, ist hier

#define NR_SR    2

die Anzahl der Schieberegister eintragen und hier

// Die Tonhöhen 'Noten', so wie MIDI sie definiert
//
const uint8_t midiNote[8*NR_SR] =
    {
//     C  C#   D  D#   E   F  F#   G
      48, 49, 50, 51, 52, 53, 54, 55,
//    G#   A   b   H   C  C#   D  D#
      56, 57, 58, 59, 60, 61, 62, 63
    };

die jeweils zugehörigen Midi-Notenwerte für diese Anzahl an 
Schieberegistern eintragen. Den Rest des Programms passt der Compiler 
auf diese Anzahl an.

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Und wie soll der angeschlossen werden.
> Einfach die VCC Leitung vom schieberegister und dem AVR auftrennen und
> dazwischen einen KERKO ??

Nein. Nix auftrennen.
Diese Verbindungen bleiben alle so wie sie sind.
Der Blockkondensator verbindet einfach nur Vcc mit GND.
Er soll die Versorungsspannung gegen Störungen abblocken. Daher der 
Name.

(In der echten Platine dann den Blockkondensator so nahe wie es geht an 
die Pins Vcc und GND ran rücken. Genau aus dem Grund sind Vcc und GND 
beim Mega zb nebeneinanderliegende Pins. Denn dann geht das recht 
einfach :-)

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

>       56, 57, 58, 59, 60, 61, 62, 63
>     };
>
> die jeweils zugehörigen Midi-Notenwerte

Wobei ich mir noch nicht im klaren bin, ob das so vernünftig ist. Im 
Prinzip sind das ja aufsteigende Werte. D.h. die könnte man auch aus der 
Tastennummer und dem Wissen welches die erste Taste in jedem Manual ist, 
errechnen.
Aber egal, kann man immer noch ändern.

[Fabian F. (fabiii9)]

Karl Heinz schrieb:
> Fabian Müller schrieb:
>
>> Und wie soll der angeschlossen werden.
>> Einfach die VCC Leitung vom schieberegister und dem AVR auftrennen und
>> dazwischen einen KERKO ??
>
> Nein. Nix auftrennen.
> Diese Verbindungen bleiben alle so wie sie sind.
> Der Blockkondensator verbindet einfach nur Vcc mit GND.
> Er soll die Versorungsspannung gegen Störungen abblocken. Daher der
> Name.
>
> (In der echten Platine dann den Blockkondensator so nahe wie es geht an
> die Pins Vcc und GND ran rücken. Genau aus dem Grund sind Vcc und GND
> beim Mega zb nebeneinanderliegende Pins. Denn dann geht das recht
> einfach :-)

Super danke.

Karl Heinz schrieb:
> Wobei ich mir noch nicht im klaren bin, ob das so vernünftig ist. Im
> Prinzip sind das ja aufsteigende Werte. D.h. die könnte man auch aus der
> Tastennummer und dem Wissen welches die erste Taste in jedem Manual ist,
> errechnen.
> Aber egal, kann man immer noch ändern.

Das wäre natürlich genial:

Die erste Taste ist bei mir, bei jedem Manual und Pedal das C2/C 
(65,406Hz)

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Das wäre natürlich genial:
>
> Die erste Taste ist bei mir, bei jedem Manual und Pedal das C2/C
> (65,406Hz)


Na dann

#define F_CPU 1000000              // 1 MHz
#define BAUD 31250                // MIDI-Baudrate (31,25kBit)

#include <avr/io.h>
#include <util/setbaud.h>

#define NR_SR    2

// Schieberegister MC14021
#define SR_DDR   DDRB
#define SR_PORT  PORTB
#define SR_PIN   PINB
#define SR_PS    PB0
#define SR_C     PB1
#define SR_DATA  PB2

#define SET_BIT(p,b)  p |= (1<<(b))
#define CLR_BIT(p,b)  p &= ~(1<<(b))
#define IS_SET(p,b)   (p & (1<<(b)))

// Midi Kommandos
#define NOTE_ON    145
#define NOTE_OFF   129

#define MIDI_NOTE_C2   12

uint8_t fetchByte()
{
  uint8_t Result = 0;
  for( uint8_t i = 0; i < 8; i++ )
  {
    Result <<= 1;

    if( IS_SET( SR_PIN, SR_DATA ) )
      Result |= 0x01;

    SET_BIT( SR_PORT, SR_C );
    CLR_BIT( SR_PORT, SR_C );
  }

  return Result;
}

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( uint8_t c )
{
  while (!(UCSRA & (1<<UDRE)))     // warten bis Senden moeglich
    ;

  UDR = c;
}

void SendNoteOn( uint8_t note )
{
  uart_putc( NOTE_ON );
  uart_putc( note );
  uart_putc( 100);
}

void SendNoteOff( uint8_t note )
{
  uart_putc( NOTE_OFF );
  uart_putc( note );
  uart_putc( 0 );
}

void scanKeys( uint8_t* keys )
{
  SET_BIT( SR_PORT, SR_PS );
  CLR_BIT( SR_PORT, SR_PS );

  for( uint8_t i = 0; i < NR_SR; i++ )
    keys[i] = fetchByte();
}

int main(void)
{
  uint8_t prevKeys[NR_SR];
  uint8_t nowKeys[NR_SR];
  uint8_t changed, pressed;
  uint8_t midiNote;

  SR_DDR |= (1<<SR_PS) | (1<<SR_C);
  uart_init();

  scanKeys( prevKeys );

  while(1)
  {
    scanKeys( nowKeys );

    midiNote = MIDI_NOTE_C2;  // die erste Note im Manual

    for( uint8_t i = 0; i < NR_SR; i++ )
    {
      changed = nowKeys[i] ^ prevKeys[i];
      pressed = nowKeys[i];

      prevKeys[i] = nowKeys[i];

      if( changed != 0x00 )
      {
        for( uint8_t bit = 0; bit < 8; ++bit )
        {
          if( changed & 0x80 )
          {
            if( !(pressed & 0x80) )
              SendNoteOn( midiNote );
            else
              SendNoteOff( midiNote );
          }
          midiNote++;
          changed <<= 1;
          pressed <<= 1;
        }
      }
      else
        midiNote += 8;
    }
  }
}

Damit solltest du 1 Manual schon mal komplett auswerten können.
8 Schieberegister hintereinander schalten, in SR_NR eine 8 eintragen, 
verkabeln und spielen.

Ich weiß noch nicht, ob ich heute am Abend dazu komme, mir was zu 
überlegen, wie wir die Sache mit mehr als einem Manual machen. Die 
Grundidee steht schon (jedes Manual hat seine eigene 8-er Kette an SR), 
aber softwaretechnisch möcht ich mir da noch was überlegen.

Was anderes.
Hast du das Teil eigentlich schon mal an einen richtigen Synthi 
angeschlossen und hörst was, oder siehst du momentan nur die 
Midi-Befehle in einem Midi-Sniffer?

[Fabian F. (fabiii9)]

Also, vielen, vielen Dank!!!

Erfunktioniert gut.

Meine Software erkennt es zwar noch nicht richtig, das ligegt aber 
gerade an der Software.
Werde mal ein paar Sachen umstellen.

Ich würde sagen jedes Manual eigene Schieberegisterkette.

Brauch ja pro kette nur drei Anschlüsse.

D.H. Ich hätte 3 Ketten => 9 Anschlüsse. Des ginge auf jeden Fall.

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Ich würde sagen jedes Manual eigene Schieberegisterkette.

Das sowieso

> Brauch ja pro kette nur drei Anschlüsse.

:-)

Das machen wir ein bischen trickreicher.
Wir lesen alle Ketten parallel ein.

> D.H. Ich hätte 3 Ketten => 9 Anschlüsse. Des ginge auf jeden Fall.

5 Anschlüsse :-)

Alle Schieberegister-ketten teilen sich P/S und C. Nur Data ist auf 
jeweils einen anderen Pin geführt. Mit einem Takt auf C kriegen wir dann 
auf 3 µC-Pins gleichzeitig das jeweils nächste Bit aller Ketten in einem 
Rutsch.

[Fabian F. (fabiii9)]

Karl Heinz schrieb:
> Alle Schieberegister-ketten teilen sich P/S und C. Nur Data ist auf
> jeweils einen anderen Pin geführt. Mit einem Takt auf C kriegen wir dann
> auf 3 µC-Pins gleichzeitig das jeweils nächste Bit aller Ketten in einem
> Rutsch.

Das wäre super.

[Karl H. (kbuchegg)]

Fabian Müller schrieb:
> Karl Heinz schrieb:
>> Alle Schieberegister-ketten teilen sich P/S und C. Nur Data ist auf
>> jeweils einen anderen Pin geführt. Mit einem Takt auf C kriegen wir dann
>> auf 3 µC-Pins gleichzeitig das jeweils nächste Bit aller Ketten in einem
>> Rutsch.
>
> Das wäre super.


ALlerdings könnte das dann schon Probleme mit dem Fan-Out des µC-Pins 
geben. Ob der alle 3*8 = 24 SR gleichzeitig treiben kann - wir werden 
sehen. Das sollte man im Vorfeld noch ausprobieren. Im schlimmsten Fall 
verpassen wir jeder SR-Kette noch einen kleinen Treiber in Form eines 
Transistors.


Was machst du mit den restlichen Pins? Schon irgendwelche Überlegungen?
vielleicht ein Poti für die Lautstärke?
LCD und 2 oder 3 Tasten für eine kleine Bedienoberfläche? zb Kanal pro 
Manual einstellen. Grundoktave jedes Manuals einstellen, ... keine 
Ahnung was man da bei Midi sonst noch so alles macht.

So wie ich das sehe, sind jetzt noch 17 Pins vom Mega ungenutzt. :-)

[Fabian F. (fabiii9)]

ja an 3 ADC Pins kommen Potis. dafür habe ich schon ein Programm.

das wird dann für die Schweller genutzt.
Und sonst: mal schauen

Wie gesagt ich hätte nichts dagegen wenn wir einfach 9 Pins benutzen.
Ich hab noch so viele frei.

dann könntest du doch einfach das Programm kopieren. oder?


Gruß
Fabi

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> dann könntest du doch einfach das Programm kopieren. oder?

:-)
Nein.

Wir machen das schon richtig und nicht mit Copy&Paste Programmierung.
Dann funktioniert das nämlich auch zuverlässig und aus einem Guss.

[Wilhelm F. (Gast)]

Fabian Müller schrieb:

> Wie gesagt ich hätte nichts dagegen wenn wir einfach 9 Pins benutzen.
> Ich hab noch so viele frei.
>
> dann könntest du doch einfach das Programm kopieren. oder?

Denk auch an die Laufzeit des Programmes. Da kommt ja bestimmt auch noch 
eine Entprellsoftware hinzu.

Im Idealfall, würde ich sagen, hängt man sogar 4 oder 8 
Schieberegisterketten an einen Port des µC, und ließt bei jedem 
Schiebetakt ein halbes oder ganzes Byte ein, anstatt bitweise.

Denn ich hatte schon mal Bedenken, daß auch kleine Verzögerungen von 
Millisekunden eine Rolle spielen könnten. So gut kenne ich mich aber mit 
Musik nicht aus. Die Musik sollte ja bestimmt nicht erst 100ms verzögert 
nach der Eingabe spielen, sondern gefühlt bestimmt echtzeitnah.

Clock und P/S kann man bestimmt mit einem kräftigen Buffer verstärken, 
falls überhaupt notwendig.

Also Clock und P/S an nur einem Pin ist bestimmt gut, wie Karl Heinz 
schrieb. Andererseits könnte man sich noch überlegen, doch separate Pins 
wegen der Belastung vieler Bausteine zu machen, wenn das sich einfach in 
der Einleseschleife unter bringen läßt. Am besten mit Einzelbitbefehlen 
nacheinander, um eben Störungen wie Peaks an der Stromversorgung zu 
minimieren.

[Karl H. (kbuchegg)]

Wilhelm F. schrieb:

> Denk auch an die Laufzeit des Programmes. Da kommt ja bestimmt auch noch
> eine Entprellsoftware hinzu.

Eben.
Die hängt bei mir noch im Hinterkopf rum. :-)

> So gut kenne ich mich aber mit Musik nicht aus.

Das ist auch mein Problem. Ich habe kein Gefühl dafür, welche Zeiten da 
zulässig sind und welche nicht mehr.

> Andererseits könnte man sich noch überlegen, doch separate Pins
> wegen der Belastung vieler Bausteine zu machen

Wär möglich.
Aber ich denke, mit zwei BC337 pro Manual sollte sich im Notfall das 
Problem beheben lassen. In dem Fall will ich doch lieber Takte sparen, 
weil ich nicht weiß, was an Zeitreserven noch notwendig sein wird.

[min (Gast)]

Ich habe gerade eine 64 buttom Tastaturmatrix mit 2 74HC165 (1/2 DIN) 
und einem 74HC595 (1/4 DOUT) realisiert. Ist allerding ein PIC oder 
STM32- project.
http://www.ucapps.de/mbhp_dio_matrix.html
Siehe auch http://www.ucapps.de/mbhp_din.html

[Fabian F. (fabiii9)]

Hallo,
so habs jetzt hinbekommen.

Jetzt läuft auch die Software. Super !!!!

Vielen Dank schon mal.


Gruß
Fabi

[Stefan W. (dl6dx)]

Karl Heinz schrieb:
> welche Zeiten da zulässig sind und welche nicht mehr.

Nach Webers* werden 10 ms Zeitdifferenz noch soeben als "gleichzeitig" 
empfunden.

Wenn man das auf Tastatur und Midi-Ausgabe aufteilt, bleiben etwa 5 ms 
übrig.

Grüße

Stefan

*) Johannes Webers, "Tonstudiotechnik", 4. Aufl. 1985

[Wilhelm F. (Gast)]

Stefan Wagner schrieb:

> Wenn man das auf Tastatur und Midi-Ausgabe aufteilt, bleiben etwa 5 ms
> übrig.

Also die Tastenentprellung müßte man dann auch auf komplette 
Entprellzyklen von bspw. maximal 3ms runter kloppen, nicht wie sonst 
üblich mal 10, 20 oder gar 50ms für eine Tastenerfassung an einer 
Maschine. Sollte aber auch machbar sein.

[Chefkoch (Gast)]

Nur mal so: Habe vor Jahren mal einen Spieltisch midifiziert und stand 
auch vor diesem Problem. War dann aber zu faul und habe ne fertige 
Lösung genommen: http://orgel.wira-electronic.de/index.htm spielt 
einwandfrei!

[Karl H. (kbuchegg)]

Wilhelm F. schrieb:
> Stefan Wagner schrieb:
>
>> Wenn man das auf Tastatur und Midi-Ausgabe aufteilt, bleiben etwa 5 ms
>> übrig.
>
> Also die Tastenentprellung müßte man dann auch auf komplette
> Entprellzyklen von bspw. maximal 3ms runter kloppen, nicht wie sonst
> üblich mal 10, 20 oder gar 50ms für eine Tastenerfassung an einer
> Maschine. Sollte aber auch machbar sein.

Wobei sich für mich die Frage erhebt, in welchem Zeitbereich sich das 
Prellen derartiger Tastenaggregate abspielt.
Meinen Informationen noch, prellen ja normale Taster ein bischen länger 
(wenn sie schlecht sind).

Hmm. Da wird die Entprellung ein bischen anders arbeiten müssen. Mit dem 
ersten Puls wird bereits der Note-On generiert, aber alle weiteren 
Note-Off bis zu einer zeitlichen Obergrenze werden unterdrückt. Hmm. 
Schön langsam versteh ich, warum RomanK gesagt hat, dass das ganze nicht 
so einfach ist :-)
Aber - das kriegen wir hin. Ist mal was anderes als die PeDa Entprellung 
und mit Störpulsen ist ja dann auch eher nicht zu rechnen.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Aber - das kriegen wir hin. Ist mal was anderes als die PeDa Entprellung
> und mit Störpulsen ist ja dann auch eher nicht zu rechnen.

Wobei.
Ich denke das würde schon funktionieren. Denn ein Instrument kann ja 
auch nicht beliebig kurze Töne erzeugen. Die einzige Modifikation wäre, 
dass ich nur das Loslassen einer Taste nach PeDa entprelle, das 
niederdrücken aber nicht. Hmm, das muss ich mir noch durch den Kopf 
gehen lassen, aber aus dem Bauch raus würde ich sagen: könnte klappen.

[Fabian F. (fabiii9)]

Karl Heinz schrieb:
> Karl Heinz schrieb:
>
>> Aber - das kriegen wir hin. Ist mal was anderes als die PeDa Entprellung
>> und mit Störpulsen ist ja dann auch eher nicht zu rechnen.
>
> Wobei.
> Ich denke das würde schon funktionieren. Denn ein Instrument kann ja
> auch nicht beliebig kurze Töne erzeugen. Die einzige Modifikation wäre,
> dass ich nur das Loslassen einer Taste nach PeDa entprelle, das
> niederdrücken aber nicht. Hmm, das muss ich mir noch durch den Kopf
> gehen lassen, aber aus dem Bauch raus würde ich sagen: könnte klappen.

Hallo,
wenn du das machen würdest, dann wäre das super.

Bin z.Zt am löten. :-)

Vielen Dank
Gruß
Fabi

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Bin z.Zt am löten. :-)

ok.
Ich warte jetzt noch auf die Rückmeldung von dir, dass du ein Manual 
komplett in Betrieb hast. Die ist für mich insofern wichtig, als ich da 
jetzt nicht zuviele Änderungen auf einmal vornehmen möchte, sonst wird 
die Fehlersuche nämlich, ich sach mal, schwierig. Die regelmässigen 
Forumsleser wissen, dass ich gerne mit kleinen Entwicklungs-Schritten 
arbeite. Vor allen Dingen dann, wenn ich die Hardware nicht vor mir 
liegen habe und alles aus der Ferne mache :-)

[Stefan W. (dl6dx)]

Karl Heinz schrieb:
> Wobei sich für mich die Frage erhebt, in welchem Zeitbereich sich das
> Prellen derartiger Tastenaggregate abspielt.

Ich hab aus Interesse mal bei den Organisten geschaut*:
Anscheinend werden bei Klaviaturen auch gern Hallgeber bzw. 
Gabellichtschranken verwendet. Da wäre das "Prellproblem" natürlich vom 
Tisch.

Gut, das steht bei einer vorhandenen Klaviatur natürlich kaum zur 
Debatte. Daher sind die Ergebnisse einer modifizierten Entprellung 
natürlich sehr interessant.

Gutes Gelingen!

Grüße

Stefan

*) 
http://sakralorgel.forumprofi.de/selbstbauprojekte-f12/klaviaturbau-kontaktierung-t246.html

[Wilhelm F. (Gast)]

Karl Heinz schrieb:

> Aber - das kriegen wir hin. Ist mal was anderes als die PeDa Entprellung
> und mit Störpulsen ist ja dann auch eher nicht zu rechnen.

Man muß es auf jeden Fall mal versuchen, und ich halte die Chancen auch 
gar nicht für so schlecht.

Aus früheren Zeiten mit dem 8051 habe ich auch noch verschiedene 
Entprellmechanismen hier liegen, z.B. auch ein Tastenfeld eingelesen. 
Ein Mechanismus war in Assembler geschrieben, und entprellte auch sehr 
schnell, innerhalb z.B. 1-2ms mehrere Tasten gleichzeitig. Das auf dem 
lahmen 8051 mit nur 2,25MHz. Auf mehrere Bytes ist sowas auch leicht 
erweiterbar.

Mit sowas könnte man es auch am Anfang mit einer einzelnen Taste 
probieren, und eine toggelnde LED dazu am µC, um mal an die kleinste 
Entprelldauer überhaupt heran zu kommen.

Also ich denke auch noch weiter darüber nach. Bin aber vorher noch ein 
wenig anderweitig beschäftigt.

[Fabian F. (fabiii9)]

Karl Heinz schrieb:
> Fabian Müller schrieb:
>
>> Bin z.Zt am löten. :-)
>
> ok.
> Ich warte jetzt noch auf die Rückmeldung von dir, dass du ein Manual
> komplett in Betrieb hast. Die ist für mich insofern wichtig, als ich da
> jetzt nicht zuviele Änderungen auf einmal vornehmen möchte, sonst wird
> die Fehlersuche nämlich, ich sach mal, schwierig. Die regelmässigen
> Forumsleser wissen, dass ich gerne mit kleinen Entwicklungs-Schritten
> arbeite. Vor allen Dingen dann, wenn ich die Hardware nicht vor mir
> liegen habe und alles aus der Ferne mache :-)


Nur damit du dich nicht wunderst.

Das mit dem Test an einem Manual, wird etwas dauern.
Muss noch Materialien bestllen und viel löten.

Werde in nöchster Zeit nicht so dazu kommen.

Melde mich dann, wenn ich es ausprobiert habe.
Gruß
Fabi

[Frank M. (ukw) (Moderator)]

Karl Heinz schrieb:
> Die einzige Modifikation wäre,
> dass ich nur das Loslassen einer Taste nach PeDa entprelle, das
> niederdrücken aber nicht. Hmm, das muss ich mir noch durch den Kopf
> gehen lassen, aber aus dem Bauch raus würde ich sagen: könnte klappen.

Ja, das war auch meine erste Idee beim Lesen dieses Threads. Da ja zwei 
Befehle geschickt werden müssen (Taste gedrückt/losgelassen), reicht 
eine Entprellung des Loslassens vollkommen aus.

Frage: Was ist der kürzeste Anschlag, den ein Mensch da schaffen kann 
bzw. da sinnvoll ist?

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Nur damit du dich nicht wunderst.
>
> Das mit dem Test an einem Manual, wird etwas dauern.
> Muss noch Materialien bestllen und viel löten.

Nein, passt schon. Lass dir Zeit.

Ist da eigentlich was angeplant, dafür saubere Platinen zu machen, oder 
verkabelst du jetzt einfach nur mal ein Manual?
Denn wenn Platinen, würde ich für einen modularen Aufbau plädieren.

Eine Hauptplatine, auf der der Mega sitzt. Dann hab ich mir überlegt, 
das eine Lösung mit kleineren Einzelplatinen, auf denen jeweils sagen 
wir mal 2 Schieberegister sitzen vernünftig sein könnte. Die 
Schieberegister-Platinen sind kaskadierbar, so dass man mehrere mit 
kurzen zb Flachbandkabelstücken miteinander verbinden kann.
Damit kann man dann die SR Platinen entlang der Länge eines Manuals 
verteilen, damit die Leitungen zu den Tasten schön kurz bleiben. Ist ja 
auch eine Geldfrage, wieviele Kabeln man da ziehen muss und wie lang die 
sind.

Also als Systemskizze so:

   Zentrale
  +-----------+
  | AtMega    o------> Midi
  |           |
  +-o-o-o-o---+
      | | |
      | | |    +-----+   +-----+   +-----+   +-----+     Manual 1
      | | +----| SR  |---| SR  |---| SR  |---| SR  |
      | |      +|||||+   +|||||+   +|||||+   +|||||+
      | |       |||||     |||||     |||||     |||||
      | |      Tasten    Tasten    Tasten    Tasten
      | |
      | |    +-----+   +-----+   +-----+   +-----+     Manual 2
      | +----| SR  |---| SR  |---| SR  |---| SR  |
      |      +|||||+   +|||||+   +|||||+   +|||||+
      |       |||||     |||||     |||||     |||||
      |      Tasten    Tasten    Tasten    Tasten
      |
      |    +-----+   +-----+   +-----+   +-----+     Manual 3
      +----| SR  |---| SR  |---| SR  |---| SR  |
           +|||||+   +|||||+   +|||||+   +|||||+
            |||||     |||||     |||||     |||||
           Tasten    Tasten    Tasten    Tasten

Die SR Module sind alle identisch. Auf jeder sitzen 2 Schieberegister 
mit den 16 Eingängen von den Tasten.
Die SR-Module sind untereinander und mit der Zentrale mit einem zb 
10-poligen Flachbandkabel (und zb STeckerleiste und Aufpressbuchsen) 
verbunden. 10-polig deshalb, weil zwischen die Signaladern jeweils eine 
Masseleitung kommt und es wahrscheinlich auch kein Fehler ist, wenn es 
mehr als eine Ader gibt, die Vcc führt.

2 Schieberegister pro Platine ist aus dem Bauch raus entstanden. Als 
Kompromiss zwischen den Leitungslängen zu den Tasten und der Forderung, 
nicht allzuviele Einzel-Platinen haben zu wollen.

[Karl H. (kbuchegg)]

Frank M. schrieb:

> Frage: Was ist der kürzeste Anschlag, den ein Mensch da schaffen kann
> bzw. da sinnvoll ist?


Gute Frage. Keine Ahnung.

Ich kann nur folgenden Erfahrungswert beisteuern.
Als die ersten Digital-Armbanduhren aufkamen, war es eine zeitlang bei 
uns Jugendlichen ein Sport: Wer schafft es, mit der Stoppuhr die 
kleinste Zeit durch Doppeldrücken des Tasters an der Uhr zu erreichen. 
D.h im Grunde ging es darum, wer am schnellsten den Daumen zweimal kurz 
hintereinander zucken lassen kann.
Unter 0.15 Sekunden zu kommen war schon recht schwierig. 1/10 Sekunde 
war schon im Bereich einer absoluten Spitzenzeit.
Wohlgemerkt: wir reden hier vom Zucken eines Daumens bei einem Weg von 
vielleicht 1 bis 2 Millimeter. Eine ganze Klavier-Taste kontrolliert 2 
mal hintereinander nieder zu drücken stell ich mir ungleich schwieriger 
vor.

[Fabian F. (fabiii9)]

Hallo,

ja danke für den Tipp, habe auch schon darüber nachgedacht.

Ich würde immer 4 Schieberegister pro Platine machen.
Dann habe ich zwei Platinen pro MAnual.

Nachdem der Kabelbaum in der Orgel schon drinliegt, ist es eigentlich 
egal, ob ich die Schieberegister auf mehrer Platinen aufteile.

Den Atmega werde ich auf eine "Masterplatine" setzen.
Untereinander werde ich die Platine mit Falchbandkabel verkabeln. (Damit 
habe ich schon Erfahrung.

Werde mal die Layouts erstellen und dann die Platinen ätzen.

Dauert aber sicher noch etwas.

Danke
Gruß
Fabi

[Karl H. (kbuchegg)]

Fabian Müller schrieb:

> Nachdem der Kabelbaum in der Orgel schon drinliegt

Kopfklatsch.
Natürlich! Daran hab ich nicht gedacht, dass es da ja schon was geben 
wird.

[Stefan W. (dl6dx)]

Frank M. schrieb:
> Was ist der kürzeste Anschlag, den ein Mensch da schaffen kann
> bzw. da sinnvoll ist?

Als obere Grenze kann man wohl 1/16 Note bei "prestissimo" (200 bpm) 
sehen. Das sind 75 ms, die aber ein durchschnittlicher Spieler nicht 
mehr technisch sauber spielen dürfte. (Bei der Geschwindigkeit dürfte es 
auf der Midi-Loop auch schon etwas eng werden...)

Grüße

Stefan

PS:
http://de.wikipedia.org/wiki/Beats_per_minute
http://hofa-college.de/online_campus/pages/tipps-amp-tricks/hofa-tools/bpm-in-msec.php

[Frank M. (ukw) (Moderator)]

Stefan Wagner schrieb:
> Frank M. schrieb:
>> Was ist der kürzeste Anschlag, den ein Mensch da schaffen kann
>> bzw. da sinnvoll ist?
>
> Als obere Grenze kann man wohl 1/16 Note bei "prestissimo" (200 bpm)
> sehen. Das sind 75 ms, die aber ein durchschnittlicher Spieler nicht
> mehr technisch sauber spielen dürfte. (Bei der Geschwindigkeit dürfte es
> auf der Midi-Loop auch schon etwas eng werden...)

Dann ist ja einigermaßen klar, ab wann die Entprellung fürs Loslassen 
greifen muss. Nach 75ms sollte ein vormals gedrückter Taster längst 
einen stabilen Zustand angenommen haben...

[Stefan W. (dl6dx)]

Karl Heinz schrieb:
> Eine ganze Klavier-Taste kontrolliert 2
> mal hintereinander nieder zu drücken stell ich mir ungleich schwieriger
> vor.

Das ist auch nicht das Schnellste, was passieren kann. Wesentlich 
häufiger ist, dass benachbarte Finger nacheinander anschlagen.

Ich hab lange nicht mehr gespielt. Aber eine Folge von Triolen* über 5 
Sekunden gestoppt ergab dann doch 36 Anschläge, also knapp 140 ms je 
Ton.

Die 75 ms, die ich eben als Abschätzung der "absoluten Obergrenze" 
berechnet habe, sind also durchaus ein realistischer Ansatz.

Grüße

Stefan

* Eine Folge von 3 Tönen, z.B. ein gebrochener Akkord.

[Fabian F. (fabiii9)]

Hallo,
habe noch eine Frage.

Habe mit Eagle einen Schaltplan entworfen.
Jetzt wollte ich ein Layout dazu erstellen.
Jetzt ist nur das Problem, dass ich nur die Freeversion von Eagle habe 
und ja die Größe der Platine beschränkt ist. => Sie reicht leider nicht 
aus.

Könnt ihr mir eine kostenlose Platinenlayouts-Software wo ich Eagle 
importieren kann und ich auch Layouts für größere Platinen erstellen 
kann empfehlen??


Vielen Dank
Gruß
Fabi

[Fabian F. (fabiii9)]

hat sch erledigt.

Danke :-)