Sehr schönes Projekt. Bin gespannt wie du das mit den arduinos gelöst hast. Eine diifenmatrix ist nix kompliziertes und spart dir viele Kabel. Ist bei der Hardware von gino Midi. Einfach umzusetzen. Es reizt mich das für einen arduino zu programmieren. Da fehlt mir noch die Erfahrung zu.
Gruß Bernd
Leider muss man berücksichtigen, dass die analogen Kontakte eventuell nicht für digital geeignet sind. Sie riskieren häufige Ausfälle. Der alte Johannus hat wahrscheinlich nur glatten Silberdraht als Kontakt. Das ist leicht zu reinigen.
Ich selbst habe diese Kontakte nicht, aber vielleicht haben andere User damit Erfahrung.
Es gibt Schemata, um die Kontakte mit Widerstand und Zenerdiode pro Taste geeignet zu machen. Ich persönlich finde die gewählten Stromwerte unnötig hoch.
This article has been most informative on the key contact question. Rather than spend the time to re-engineer the key contacts, I’ve chosen to preserve the time-honored open-air silver wire contacts and revert to a parallel sampling scheme. I will connect the existing key contacts such that each key switches a 100 mA wetting current on and off as the organist plays. Then all I need is a way to translate 100 mA of current into a 5-volt logic-level signal. Simplicity and reliability are key, as there are 305 keys and 32 pedals! Here’s the simplest circuit I can build:
Schön, schau einmal nach ob in diesem Instrument ein Schaltnetzteil eingebaut oder ob es mit Trafos ausgestattet ist.
Hier wurde schon darüber berichtet, dass billige Elektrolytkondensatoren auslaufen und die Platine verätzen können. Steigt durch fehlende Kapazität die Versorgungsspannung für den Prozessor ist die Orgel unreparierbar hinüber. Der Fehler muss nicht, kann aber eintreten.
Es kann sich lohnen diese (meist smd) Kondensatoren zu ersetzen. Ist bissl Aufwand
Ich kann mal nachschauen, aber wahrscheinlich kein Schaltnetzteil. Wobei das irrelevant geworden ist, da die "alte" Orgel tot ist. Ich nutze nurmehr die vorhandenen Klaviaturen und Pedal sowie deren Verkabelung und Kontakte.
Eine diifenmatrix ist nix kompliziertes und spart dir viele Kabel.
Ja das stimmt. Tatsächlich sind auch viele Keyboards so aufgebaut, wie ich gelernt habe. Nur wie verhindert man "Geistertöne"? Sprich wenn sich die Spannungspfade bei mehr als X (2 oder 3?) gedrückten tasten kreuzen könnten?
Leider muss man berücksichtigen, dass die analogen Kontakte eventuell nicht für digital geeignet sind. Sie riskieren häufige Ausfälle. Der alte Johannus hat wahrscheinlich nur glatten Silberdraht als Kontakt. Das ist leicht zu reinigen.
Ich selbst habe diese Kontakte nicht, aber vielleicht haben andere User damit Erfahrung.
Also in der Original-Johannus-Schaltung wurde auch mit relativ hohen Spannungen gearbeitet. Bei Arduinos ist die Spannung üblicherweise 5V, beim Arduino Due nur 3,3V. Tastenkontakt kommt über mutmaßlich Silberfeder auf Masse-Metallstange (weiß nicht, welche Legierung). Bilder dazu folgen. Das Ergebnis funktioniert gut, einzig Manual 2 spielt sich bei Akkorden etwas "pneumatisch". Meine Vermutung ist, dass hier die Kontakte bisschen oxidiert sind. Da muss ich mal mechanisch und /oder chemisch reinigen. Gibt es da Erfahrungen? Einfach mit Stahlwolle abreiben?
Pro Taste ein Pin ist aber alles andere als eine ideale Sache. Kannst du das ganze nicht aufteilen und eine Matrix daraus machen? Dann würde im Grunde ein Arduino für alles reichen und auch der Code wird sehr viel besser. Ich kenne den Code von dem besagten Video und der ist wirklich nicht gut.
Ein wichtiger Hinweis für dein Projekt:
Nimm bitte das MidiUSB.flush(); aus dem Code raus!
Der Arduino Due hat bei seinem USB Controller nämlich eine Besonderheit die mir auch auf die Füße gefallen ist. Der Controller nimmt nur in bestimmten Zeitabständen Informationen entgegen. Sendet man zu schnell Daten, dann werden diese einfach verworfen. Bedeutet ein Midi Signal kommt nicht an deinem Rechner an. Nach einer Aktion braucht der Controller einige Zyklen um wieder Daten anzunehmen. Wenn du je nach Code für jede Taste ein SendMidi mit einem flush machst, dann kannst du innerhalb kurzer Zeit hunderte Anfragen stellen, vor allem wenn mal ein Kontakt am prellen ist oder du viele Tasten gleichzeitig spielst. Das Ergebnis in der Praxis ist dann, dass einzelne Töne nicht gespielt werden oder als Heuler zurückbleiben.
Daher nutze flush nicht und überlasse es der Bibliothek das alleine zu machen, dann gibt es keine Probleme. Natürlich wird ohne das flush ein Signal nicht sofort versendet, sondern verzögert. Wir reden hier aber über weniger als ein Bruchteil einer Millisekunde. Ich habe BTW um die Ursache zu finden bestzimmt 100 Stunden debuggen müssen, da es absurd ist wenn alles in der Software stimmt aber die Signale hinten nicht korrekt rauskommen..
Danke für dein Feedback. Ein paar Fragen dazu.
Was ist daran nicht gut, keine Matrix zu verwenden? Wird die Funktionsweise beeinträchtigt oder ist es "nur" der Umstand, dass ich sonst mit weniger Arduinos auskommen könnte? Beim Spielen bemerke ich nämlich keine Nachteile.
Was macht den Code nicht gut? Ich meine er basiert auf dem Standardbeispiel aus der Bibliothek. Was mir daran auch aufgefallen war, war die große Delay Zeit. Habe ich auf ein Minimum zurückgefahren. Ganz ohne hatte ich merkwürdige Tonfehler.
Das mit dem Flush-Befehl probiere ich auch aus. Ist ja schnell rausgenommen. Die von dir beschriebenen Fehler habe ich bislang nicht bemerkt, oder aber überhört.
Die Schaltung einer Diodenmatrix ist in einem Beitrag eingestellt. Ich kann ihn gerne suchen
Ja kannst du ja bei Gelegenheit mal raussuchen, eilt aber nicht. Wenn ich mal Zeit und Muße habe baue ich vlt. noch einmal hin zu einer Matrix um. Für den Moment funktioniert erst einmal alles gut.
Was mir daran auch aufgefallen war, war die große Delay Zeit. Habe ich auf ein Minimum zurückgefahren. Ganz ohne hatte ich merkwürdige Tonfehler.
Das wird vermutlich am Prellen der Kontakte liegen. Wenn du eine Taste drückst, dann Prellt dieser ja. Er schwingt also einige Millisekunden hin und her, öffnet und schließt sich quasi. Je nach Delay kann es dann dazu führen, dass dein Arduino denkt du würdest gerade innerhalb einer Millisekunde 400 mal die Taste drücken und sendet im Zweifel 400 Mal Taste gedrück und losgelassen. Das ist nicht nur eine Qual für die Software die damit was anfangen muss, sondern äußert sich auch in solchen Tonfehler.
Was ist daran nicht gut, keine Matrix zu verwenden? Wird die Funktionsweise beeinträchtigt oder ist es "nur" der Umstand, dass ich sonst mit weniger Arduinos auskommen könnte?
Das ist einfacher zu schalten. Im Grunde brauchst du für 64 Tasten 64 Kabel/Pins plus 1, also 65 Pins. Bei einer 8x8 Matrix könntest du die 64 Tasten mit nur 16 Pins abfragen. Bei zwei Manualen könntest du mit einer cleveren Schaltung und Programmierung sogar zwei Manuale mit jeweis 64 Tasten mit 24 Pins abarbeiten. Mit 32 Pins zusätzlich noch 64 Schalter.
Vielleicht als Anregung mal ein Ausschnitt aus meinem Code. Dieser fragt 2 Manuale und ein Pedal ab, sendet die entsprechenden Tastencodes dann aus der Liste. Aber Vorsicht der Code ist auf mich zugeschnitten. Viele Abschnitte sind zwar doppelt, so ist es aber einfacher als mit verschachtelten Schleifen.
#include <MIDIUSB.h>
byte inputsManual1[] = {22,23,24,25,26,27,28,29}; //Deklariere inputs und outputs
byte inputsManual2[] = {38,39,40,41,42,43,44,45};
byte inputsPedal1[] = {A2, A3, A4, A5, A6, A7, A8, A9};
#define inCountManual1 sizeof(inputsManual1)/sizeof(inputsManual1[0])
#define inCountManual2 sizeof(inputsManual2)/sizeof(inputsManual2[0])
#define inCountPedal1 sizeof(inputsManual2)/sizeof(inputsPedal1[0])
byte outputsManual1[] = {30,31,32,33,34,35,36,37};
byte outputsManual2[] = {46,47,48,49,50,51,52,53};
byte outputsPedal1[] = {A0, A1};
#define outCountManual1 sizeof(outputsManual1)/sizeof(outputsManual1[0])
#define outCountManual2 sizeof(outputsManual2)/sizeof(outputsManual2[0])
#define outCountPedal1 sizeof(outputsPedal1)/sizeof(outputsPedal1[0])
int layout[outCountManual1][inCountManual1] = { //layout grid for Manuals
//Manual 1+2
{48,47,46,45,44,43,42,41},
{56,55,54,53,52,51,50,49},
{64,63,62,61,60,59,58,57},
{72,71,70,69,68,67,66,65},
{80,79,78,77,76,75,74,73},
{88,87,86,85,84,83,82,81},
{97,96,95,94,93,92,91,89},
{105,104,103,102,101,100}
};
int layoutRegister[outCountManual2][inCountManual2] = { //layout grid for Register
//Manual 1
{48,47,46,45,44,43,42,41},
{56,55,54,53,52,51,50,49},
{64,63,62,61,60,59,58,57},
{72,71,70,69,68,67,66,65},
{80,79,78,77,76,75,74,73},
{88,87,86,85,84,83,82,81},
{97,96,95,94,93,92,91,89},
{105,104,103,102,101,100}
};
int layoutRegisterChannel[outCountManual2][inCountManual2] = { //Channel Register
//Manual 2
{48,47,46,45,44,43,42,41},
{56,55,54,53,52,51,50,49},
{64,63,62,61,60,59,58,57},
{72,71,70,69,68,67,66,65},
{80,79,78,77,76,75,74,73},
{88,87,86,85,84,83,82,81},
{97,96,95,94,93,92,91,89},
{105,104,103,102,101,100}
};
int layoutPedal[outCountPedal1][inCountPedal1] = { //layout grid for Pedal
//Manual 1+2
{52,51,50,49,48,0,0,0},
{60,59,58,57,56,55,54,53}
};
int keyDownManual1[outCountManual1][inCountManual1];
bool keyLongManual1[outCountManual1][inCountManual1];
int keyDownManual2[outCountManual2][inCountManual2];
bool keyLongManual2[outCountManual2][inCountManual2];
int keyDownPedal1[outCountPedal1][inCountPedal1];
bool keyLongPedal1[outCountPedal1][inCountPedal1];
/**** Funktionen für MIDI ***************************************************/
void noteOn(byte channel, byte pitch, byte velocity) {
midiEventPacket_t noteOn = {0x09, 0x90 | channel, pitch, velocity};
MidiUSB.sendMIDI(noteOn);
//MidiUSB.flush();
delayMicroseconds(300);
}
void noteOff(byte channel, byte pitch, byte velocity) {
midiEventPacket_t noteOff = {0x08, 0x80 | channel, pitch, velocity};
MidiUSB.sendMIDI(noteOff);
//MidiUSB.flush();
delayMicroseconds(300);
}
void setup(){
for(int i=0; i<outCountManual1; i++){ //declaring all the outputs and setting them high
pinMode(outputsManual1[i],OUTPUT);
digitalWrite(outputsManual1[i],HIGH);
pinMode(outputsManual2[i],OUTPUT);
digitalWrite(outputsManual2[i],HIGH);
}
for(int i=0; i<inCountManual2; i++){ //declaring all the inputs and activating the internal pullup resistor
pinMode(inputsManual1[i],INPUT_PULLUP);
pinMode(inputsManual2[i],INPUT_PULLUP);
}
for(int i=0; i<outCountPedal1; i++){ //declaring all the outputs and setting them high
pinMode(outputsPedal1[i],OUTPUT);
digitalWrite(outputsPedal1[i],HIGH);
}
for(int i=0; i<inCountPedal1; i++){ //declaring all the inputs and activating the internal pullup resistor
pinMode(inputsPedal1[i],INPUT_PULLUP);
}
Serial.begin(9600); //establishing Serial link and initializing keyboard
Serial.println("Connected");
}
//Main loop going through all the keys, then waiting 0.5ms
void loop() {
//Manuall 1
for (int i=0; i<outCountManual1; i++)
{
digitalWrite(outputsManual1[i],LOW); //setting one row low
delayMicroseconds(5); //giving electronics time to settle down
for(int j=0; j<inCountManual1; j++)
{
if(digitalRead(inputsManual1[j]) == LOW)
{
keyPressedManual1(i,j, 1); //calling keyPressed function if one of the inputs reads low
}
else if(keyDownManual1[i][j] != 0) //resetting the key if it is not pressed any more
{
resetKeyManual1(i,j, 1);
}
}
digitalWrite(outputsManual1[i],HIGH);
delayMicroseconds(500); //setting the row high and waiting 0.5ms until next cycle
}
//Manuall 2
for (int i=0; i<outCountManual2; i++)
{
digitalWrite(outputsManual2[i],LOW); //setting one row low
delayMicroseconds(5); //giving electronics time to settle down
for(int j=0; j<inCountManual2; j++)
{
if(digitalRead(inputsManual2[j]) == LOW)
{
keyPressedManual2(i,j, 2); //calling keyPressed function if one of the inputs reads low
}
else if(keyDownManual2[i][j] != 0) //resetting the key if it is not pressed any more
{
resetKeyManual2(i,j, 2);
}
}
digitalWrite(outputsManual2[i],HIGH);
delayMicroseconds(500); //setting the row high and waiting 0.5ms until next cycle
}
//Pedal 1
for (int i=0; i<outCountPedal1; i++)
{
digitalWrite(outputsPedal1[i],LOW); //setting one row low
delayMicroseconds(5); //giving electronics time to settle down
for(int j=0; j<inCountPedal1; j++)
{
if(digitalRead(inputsPedal1[j]) == LOW)
{
keyPressedPedal1(i,j, 3); //calling keyPressed function if one of the inputs reads low
}
else if(keyDownPedal1[i][j] != 0) //resetting the key if it is not pressed any more
{
resetKeyPedal1(i,j, 3);
}
}
digitalWrite(outputsPedal1[i],HIGH);
delayMicroseconds(500); //setting the row high and waiting 0.5ms until next cycle
}
}
// ==============
// == Manual 1 ==
// ==============
//if a key is pressed, this Funtion is called and outputs to serial the key location, it also sends the keystroke if not already done so
void keyPressedManual1(int row, int col, int kanal){
if(keyDownManual1[row][col]==0){ //if the function is called for the first time for this key
int kanal = 1;
noteOn(kanal, layout[row][col], 127);
}
keyDownManual1[row][col]++;
}
void resetKeyManual1(int row, int col, int kanal){ //resetting the variables after key is released
keyDownManual1[row][col] = 0;
keyLongManual1[row][col] = false;
noteOff(kanal, layout[row][col], 127);
}
// ==============
// == Manual 2 ==
// ==============
void keyPressedManual2(int row, int col, int kanal){
if(keyDownManual2[row][col]==0){ //if the function is called for the first time for this key
noteOn(layoutRegisterChannel[row][col], layoutRegister[row][col], 127);
}
keyDownManual2[row][col]++;
}
void resetKeyManual2(int row, int col, int kanal){ //resetting the variables after key is released
keyDownManual2[row][col] = 0;
keyLongManual2[row][col] = false;
noteOff(layoutRegisterChannel[row][col], layoutRegister[row][col], 127);
}
// =============
// == Pedal ==
// =============
void keyPressedPedal1(int row, int col, int kanal){
if(keyDownPedal1[row][col]==0){ //if the function is called for the first time for this key
noteOn(kanal, layoutPedal[row][col], 127);
}
keyDownPedal1[row][col]++;
}
void resetKeyPedal1(int row, int col, int kanal){ //resetting the variables after key is released
keyDownPedal1[row][col] = 0;
keyLongPedal1[row][col] = false;
noteOff(kanal, layoutPedal[row][col], 127);
}Kurzer Nachtrag, mit einem Pi Pico für 4 Euro geht es sogar noch leichter 
Irgendwo hier im Forum gibt es einen Beitrag dazu. Einfach die Pins eintragen für Inputs und Outputs und fertig
# Vorbereitung
#
# Benötigt werden:
# - Adafruit CircuitPython: https://learn.adafruit.com/getting-started-with-raspberry-pi-pico-circuitpython
#
# Zusätzlich die CircuitPython libs: adafruit_midi
# (in das Verzeichnis "lib" auf dem Pi Pico kopieren)
#
# Diese Datei als code.py auf dem Raspberry Pi Pico CIRCUITPY Laufwerk speichern!
# Importe
# =======
import time
import board
import busio
import usb_midi
import keypad
import adafruit_midi
from adafruit_midi.note_off import NoteOff
from adafruit_midi.note_on import NoteOn
from adafruit_bus_device.i2c_device import I2CDevice
from digitalio import DigitalInOut, Direction, Pull
# Variablen
#==========
midiChannelOut = 1
midiChannelIn = 1
midi = adafruit_midi.MIDI(midi_out=usb_midi.ports[midiChannelIn], out_channel=midiChannelOut)
# Pins für die Tastenmatrix
km = keypad.KeyMatrix(
row_pins=(board.GP0, board.GP1),
column_pins=(board.GP2, board.GP3, board.GP4),
)
# Midi Keycode für die dazugehörige Taste
KEYCODE = (51, 52, 53, 54, 55, 56)
# sendNoteOn sendet ein NoteON mit den übergebenen
# Parameter
def sendNoteOn(keycode, velocity=127):
midi.send(NoteOn(keycode, velocity))
# sendNoteOn sendet ein NoteON mit den übergebenen
# Parameter
def sendNoteOff(keycode, velocity=0):
midi.send(NoteOff(keycode, velocity))
# Hauptschleife
while True:
event = km.events.get()
if event:
sendNoteOn(KEYCODE[event.key_number]) if event.pressed else sendNoteOff(KEYCODE[event.key_number])Ist der Code auch für Arduino Due? Dann würde ich wenn ich bei meinem Bericht an der Stelle bin sowohl "meinen", als auch deinen Code platzieren. Dann können eventuelle Nachahmer ja für sich entscheiden. Berndkoeln sucht ja zum Beispiel nach einem Matrix-Code.
Der erste Code ist für den Due
DAnke dür den Code, habe schon gesucht hier...
Also ich kann ehrlich gesagt immernoch nicht erkennen, was an meiner Vorgehensweise oder dem verwendeten Code "schlecht" sein soll. Nach deinen Ausführungen scheint mir das einzige Manko zu sein, dass ich mehr als einen Arduino nutze. Na und? In meiner persönlichen Kosten-Nutzen-Abwägung war das die einfachere Vorgehensweise. Denn wie ich noch zeigen werde, hatte ich nichts zu verkabeln, denn es war bereits alles verkabelt. Mein Ziel war nicht, den elegantesten und Arduino-ärmsten Weg zu gehen. Mein Ziel war, mit möglichst wenig Zeiteinsatz eine funktionierende GO-Orgel zu bekommen, denn Zeit habe ich kaum. Und das ist mir mit meinem Ansatz gelungen: nach 3 Wochen hatte ich eine spielfertige Orgel, nach 4 inkl. Setzer-Anlage. In diesem Zeitrahmen muss man berücksichtigen, dass ich vorher Arduino- und Midifizierungs-mäßig komplett blank war. Allein diese Recherche hat viel Zeit gekostet. Mit Matrix wollte ich mich daher nicht beschäftigen. Ich merke im Übrigen auch keine Nachteile beim Spielen, egal ob flinke französische Toccata oder große Akkorde in beiden Händen.
Ich zeige hier also nicht den Weg der Midifizierung, sondern lediglich meinen. Wenn sich da einer etwas von mitnehmen kann, gut. Wenn nicht, auch ok. Vielleicht sollte ich noch anfügen, dass ich bereits fertig bin und hier in der Retroperspektive berichte. Ich werde also eine funktionierende Orgel nicht ohne Not noch einmal anfassen. Die nächste baue ich dann sicher mit Diodenmatrix 
Hilfreich war die Diskussion dennoch, denn du konntest Bernd weiterhelfen
oder dem verwendeten Code "schlecht" sein soll.
Der Code ist einfach nicht sinnvoll. Er funktioniert zwar, aber so macht man das nicht. Die ca. 150 Zeilen Code könnte man mühelos und übersichtlich gut erweiterbar in vielleicht 20 Zeilen packen.
bool taste0Alt = LOW;
bool taste1Alt = LOW;
bool taste2Alt = LOW;
bool taste3Alt = LOW;
bool taste4Alt = LOW;
bool taste5Alt = LOW;
bool taste6Alt = LOW;
bool taste7Alt = LOW;
bool taste8Alt = LOW;
bool taste9Alt = LOW;
bool taste10Alt = LOW;
bool taste11Alt = LOW;
bool taste12Alt = LOW;
bool taste13Alt = LOW;
bool taste14Alt = LOW;
bool taste15Alt = LOW;
bool taste16Alt = LOW;
bool taste17Alt = LOW;
bool taste18Alt = LOW;wäre so sinnvoll:
int AnzahlTaste = 19;
bool TasteAlt[AnzahlTaste];Dann kannst du nämlich mühelos diese endlosen Zeilen sparen
taste0Alt = MidiButton(22, 41, taste0Alt);
taste1Alt = MidiButton(23, 42, taste1Alt);
taste2Alt = MidiButton(24, 43, taste2Alt);
taste3Alt = MidiButton(25, 44, taste3Alt);
taste4Alt = MidiButton(26, 45, taste4Alt);
taste5Alt = MidiButton(27, 46, taste5Alt);
taste6Alt = MidiButton(28, 47, taste6Alt);
taste7Alt = MidiButton(29, 48, taste7Alt);
taste8Alt = MidiButton(30, 49, taste8Alt);
taste9Alt = MidiButton(31, 50, taste9Alt);
taste10Alt = MidiButton(32, 51, taste10Alt);
taste11Alt = MidiButton(33, 52, taste11Alt);
taste12Alt = MidiButton(34, 53, taste12Alt);
taste13Alt = MidiButton(35, 54, taste13Alt);
taste14Alt = MidiButton(36, 55, taste14Alt);
taste15Alt = MidiButton(37, 56, taste15Alt);
taste16Alt = MidiButton(38, 57, taste16Alt);
taste17Alt = MidiButton(39, 58, taste17Alt);
taste18Alt = MidiButton(40, 59, taste18Alt);mit:
for(int i=0; i<AnzahlTaste; i++){
{
tasteAlt[i] = MidiButton....;
}Sowas wie in dem Beispiel lässt sich nämlich unheimlich schlecht warten. Ändere mal einen Pin und das Programm ist quasi schneller neugeschrieben als angepasst.
Wie gesagt es funktioniert, aber man tut sich selbst mit so einem Konstrukt keinen Gefallen, außer man ist sich sicher niemals wieder was daran ändern zu müssen
Ob nun ein nachgeschalteter Scanner 64 Kontakte einzeln abfragt oder hintereinander 8x8 Kontakte und weiterleitet gibt keinen Zeitvorteil eines der Systeme.
Ich möchte noch einwerfen, dass in dem Code von werdeElektroniker die Pins am Ground hängen. Es wird im Grunde der Widerstand geprüft was meiner Erfahrung nach die denkbar schlechteste Idee ist. Besser ist es statt Ground eine Spannung zu nehmen und an den Pins zu schauen ob diese anliegt (also Taste gedrückt).
Da reicht schon ein berühren von einem Kontakt damit der Arduino annimmt eine Verbindung zu Ground liegt an. Auch eine schlechte Isolation oder andere Einflüsse sorgen da gerne für Phantomereignisse.
Wobei ich mir jetzt nicht sicher bin, ich meine hier etwas gelesen zu haben, dass in deiner Lösung eine Spannung anliegt und nicht gegen Ground geprüft wird?
Ob nun ein nachgeschalteter Scanner 64 Kontakte einzeln abfragt oder hintereinander 8x8 Kontakte und weiterleitet gibt keinen Zeitvorteil eines der Systeme.
Ich muss noch als Nachtrag etwas einwerfen. Doch es gibt einen Zeitvorteil. Die Matrix ist langsamer. Beim durchgehen dieser müssen Pins umgeschaltet werden und das benötigt eine gewisse Zeit bevor man zuverlässig nach dem Verändern des Pins prüfen kann. Bedeutet also die Matrix ist tatsächlich langsamer.
Bei dieser Anwendung spielt das aber keine Rolle, da wir hier über Microsekunden sprechen, dass hat also praktisch keinerlei Relevanz und ist eher in anderen Szenarien eine Sache die man bedenken sollte.
Alles anzeigenDer Code ist einfach nicht sinnvoll. Er funktioniert zwar, aber so macht man das nicht. Die ca. 150 Zeilen Code könnte man mühelos und übersichtlich gut erweiterbar in vielleicht 20 Zeilen packen.
[...]
wäre so sinnvoll:
[...]
Dann kannst du nämlich mühelos diese endlosen Zeilen sparen
mit:
Codefor(int i=0; i<AnzahlTaste; i++){ { tasteAlt[i] = MidiButton....; }
Du hast aus Sicht eines Profis, der zu zweifellos zu sein scheinst, in allen Punkten inhaltlich Recht. Für mich als Anfänger sieht es aber ganz anders aus: Die Pflicht ist, dass der Code sauber funktioniert. Tut er. Die Kür ist, dass er elegant, mit wenig Zeilen und wartungsfreundlich programmiert ist. Das ist er nicht, das weiß ich auch. Aber wieso von einem Anfänger verlangen?
Als du angefangen hast mit Orgelspielen, konntest du da blindes Pedalspiel oder hast du immerzu runtergeguckt? Sinnvoll ist runtergucken nicht. Und man kann auch viel schneller üben, wenn man nicht ständig runterguckt. Außerdem ergibt das ein ziemliches Gehampel. Am Anfang aber trotzdem notwendig. Den Rest lernt man mit der Zeit.
Zu warten ist an dem Code übrigens nichts, er braucht auch keinen Ölwechsel oder hat Veschleißteile. Er funktioniert, und das kann er jetzt solange tun, bis der Arduino den Löffel reicht. Ich wollte mir selbst auch nur den Gefallen tun, meine Orgel ans Laufen zu kriegen, mehr nicht.
Im Übrigen habe ich nicht geschrieben, dass ich den Elektroniker-Code kopiert habe. Ich habe wörtlich geschrieben, dass ich ihn analysiert und für mich abgewandelt habe. Eine ganz wesentliche Änderung war, dass ich aus den Input-Pins Input-Pullup-Pins gemacht habe. Ersteres war bei ersten Tests in der Tat sehr fragil, letzteres funktioniert wie schon oft geschrieben stabil, perfomant und tadellos.
Ich würde vorschlagen, den Rest der Diskussion zu führen, wenn du tatsächlich den bei mir in Verwendung stehenden Code gesehen hast. Wobei ich sie in Teilen nicht als besonders zielführend empfinde. Momentan liegt dir lediglich die Vorlage vom Elektroniker und eine vage Vorstellug vor. Alternativ könnten wir es auch so machen, dass du meinen Code bekommst, optimieren kannst, und wir stellen dann den optimierten hier zur Verfügung sowie den Matrix-Code. Dann kann sich jeder Leser aussuchen, was er benutzen will.
Das kann vlt. Haralder beantworten. Ich weiß nur, dass der Arduino Due Hardware-mäßig leistungsfähiger und schneller ist, als manch andere, z.B. UNO oder MEGA.
