Lichtpultsoftware Fernbedienung mit Drehencoder und Programmierbaren Tasten über USB

jo hast recht. @rebel_tilt: Rebecca wiee magst du weitermachen:
grundlegend ins Programmieren einsteigen oder nur konkrete Fragen zum anpassen eines vorhanden Programms stellen?
Der Leonardo kommt wahrscheinlich erst morgen. Du könntest schon mal bei https://www.tinkercad.com/ in den Arduino-Simulator reinschauen um ein paar grundlegende Sachen zu lernen. Da kann man recht schnell kleine Demo-Programm zum LED-Blinken lassen usw. erstellen.

An den Arduino-Simulator kommt man kommt nur dran wenn man sich registriert.
vgs

Auf diese Idee bin ich noch nicht gekommen, gute Anregung :slightly_smiling_face:

@rebel_tilt: Da ich keinen Leonardo habe, probiere ich mit meinem Teensy 3.2, der nach ein paar Anpassungen auch einwandfrei auf den Drehencoder reagiert:

grafik

// abgewandelt von: https://github.com/maxgerhardt/rotary-encoder-over-mcp23017/blob/master/lib/Adafruit-MCP23017-Arduino-Library-master/examples/interrupt/interrupt.ino
#include <Wire.h>
#include <Adafruit_MCP23017.h>

Adafruit_MCP23017 mcp;

byte ledPin = 13;

// Interrupts from the MCP will be handled by this PIN
byte arduinoIntPin = 3;

volatile boolean activByInterrupt = false;

// Two pins at the MCP (Ports A/B where some buttons have been setup.)
// Buttons connect the pin to grond, and pins are pulled up.
byte rotEncPinA = 8;
byte rotEncPinB = 9;
byte ledEncPinA = 4;
byte ledEncPinB = 5;

void setup() {
  pinMode(ledPin, OUTPUT);  // use the p13 LED as debugging

  //Serial.begin(115200);
  //Serial.println("MCP23007 Interrupt Test");

  mcp.begin();      // use default address 0

  // We mirror INTA and INTB, so that only one line is required between MCP and Arduino for int reporting
  // The INTA/B will not be Floating
  // INTs will be signaled with a LOW
  mcp.setupInterrupts(true, false, LOW);

  // configuration for a button on port A
  // interrupt will triger when the pin is taken to ground by a pushbutton
  mcp.pinMode(rotEncPinA, INPUT);
  mcp.pullUp(rotEncPinA, HIGH);  // turn on a 100K pullup internally
  mcp.setupInterruptPin(rotEncPinA, FALLING);
  mcp.pinMode(ledEncPinA, OUTPUT);

  // similar, but on port B.
  mcp.pinMode(rotEncPinB, INPUT);
  mcp.pullUp(rotEncPinB, HIGH);  // turn on a 100K pullup internall
  mcp.setupInterruptPin(rotEncPinB, FALLING);
  mcp.pinMode(ledEncPinB, OUTPUT);

  mcp.digitalWrite(ledEncPinA, HIGH);
  mcp.digitalWrite(ledEncPinB, HIGH);
  delay(500);
  mcp.digitalWrite(ledEncPinA, LOW);
  mcp.digitalWrite(ledEncPinB, LOW);

  // And we setup a callback for the arduino INT handler.
  pinMode(arduinoIntPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(arduinoIntPin), intCallBack, FALLING);
}

// The int handler will just signal that the int has happen
// we will do the work from the main loop.
void intCallBack() {
  activByInterrupt = true;
}

void handleInterrupt() {
  // disable interrupts while handling them.
  detachInterrupt(digitalPinToInterrupt(arduinoIntPin));

  // Get more information from the MCP from the INT
  uint8_t pin = mcp.getLastInterruptPin();
  uint8_t val = mcp.getLastInterruptPinValue();

  if (pin == rotEncPinA) {
    mcp.digitalWrite(ledEncPinA, HIGH);
    //Serial.println("R dreht links");
    Keyboard.println("R dreht links");
  }
  if (pin == rotEncPinB) {
    mcp.digitalWrite(ledEncPinB, HIGH);
    //Serial.println("R dreht rechts");
    Keyboard.println("R dreht rechts");
  }

  // we have to wait for the interrupt condition to finish
  while ( ! (mcp.digitalRead(rotEncPinB) && mcp.digitalRead(rotEncPinA) ));
  activByInterrupt = false;
  // And we setup a callback for the arduino INT handler.
  attachInterrupt(digitalPinToInterrupt(arduinoIntPin), intCallBack, FALLING);
  mcp.digitalWrite(ledEncPinA, LOW);
  mcp.digitalWrite(ledEncPinB, LOW);
}

void loop() {
  digitalWrite(ledPin, digitalRead(arduinoIntPin));
  if(activByInterrupt) handleInterrupt();
}

Ausgabe im Editor:

grafik

Über Details habe ich nicht weiter nachgegrübelt, da die Bibliotheken für den Leonardo sicherlich etwas anders ticken. Interrupt ja oder nein ist sicherlich ein Nachdenken wert. MCP mit Interrupt und im Arduino pollen habe ich auch probiert, funktioniert ebenfalls.

Vielen Dank für eure Überlegungen

wie viele Taster genau?
Traumhaft Ideal - 104
Toll - 64
OK - 32

Spricht etwas dagegen die Taster in einer Matrix zu verschalten?
Nein, wenn ich es richtig verstanden habe, macht das jede Handelübliche Tastatur auch.
Alle Gamecontroller die ich mir näher Angesehen habe, arbeiten ja auch so. Also Matrix JA.

wie viele Drehregler?
Traumhaft Ideal - 8
OK - 4
Bei 4 Drehreglern und/oder 32 Tastern baue ich das Teil eben 2mal

hat jeder Drehregler auch einen Taster/Druckpunkt?
Die, die ich bestellt habe: ja. Im Original nein... Wenn ich so überlege... ein Klasse Gimmik fällt mir da gerade ein...
Hier könnte ich mir eine Funktion vorstellen: auf den Regler Drücken und der Wert gibt 25 + Impulse (also überspringe ich 25 Stufen drehen) Irgendwo noch ein "MODE" Umschalter der dann auf 25 - wechselt und als dritte Stufe AUS, was im Live Betrieb wichtig ist, damit man da aus Versehen keinen Unfug mit betreibt. Das ganze evtl. mit einem ZählPuffer? also 4mal darauf Tippen und der Wert gibt 100 Steps vor... Der Mode Schalter steuert dann noch eine LED an , die je nach Mode die Farbe Wechselt. Das wäre dann aber schon die MEGABonusRunde.
... oder kleiner Gedacht: einfach wie bei einer normalen Tastatur: so lange man darauf drückt macht er Automatisch wiederholte Eingabe.

> das ganze soll als HID/via USB an einen PC gesandt werden
Genau, an dem kleinen WIN 10 Rechner ist ein aktives USB HUB, an dieses möchte ich das ganze Anschließen.

Gewünschtes Ausgabe Format: Es müssen Tastenkombinationen möglich sein:
also Strg, Alt, Shift müssen mit einer Taste zusammen Funktionieren. Auch Kombinationen aus Strg,Shift&Alt

wiee magst du weitermachen:
Grundlegend ins Programmieren einsteigen oder nur konkrete Fragen zum anpassen eines vorhanden Programms stellen?

Für dieses Projekt erhoffe ich mir von euch eine BauAnleitung, da ich leider noch viiiieeeel zu wenig Verstehe, von dem was ihr Schreibt.

  • Dafür Benötige ich also leider auch einen Plan für die Verdrahtung: was an Welchem Pin gehört... ähnlich wie in dem Video von der Game Controller Box, denn das bekomme ich hin.
  • ein Script, wo ich dann nur noch die TastenKombinationen Eingeben/Ändern muß.
    Ehrlich gesagt, bin ich da zu ungeduldig, damit zu Warten bis ich so etwas selbst hinbekomme.
  • Und gut, sucht mir den Arduino raus, von dem ihr meint, der am besten geeignet ist, die Preise sind ja nun nicht so unerreichbar. Allerdings darf es auch gerne der günstigere sein. Ich warte dann mit der nächsten Bestellung, bis ihr einen Nenner habt.

Also leider auch Grundlagenarbeiten

Das ist jetzt schon wirklich sehr viel verlangt von einem Newby, ich weiß. Und es ist definitiv nicht selbstverständlich.

grundlegend ins Programmieren einsteigen
Das natürlich auch, aber erst als B Projekt. Zu spannend finde ich diesen Bereich, um es nicht lernen zu wollen. Viele Ideen schlummern in mir, Ideen die mit Arduionos scheinbar zu realisieren gehen. Das UNO StartPaket kommt hoffentlich bald und damit möchte ich dann so langsam Step by Step in die Materie Einsteigen. Einige von den Tests durchführen... und Vieeeele AHAs erleben.

Ich habe von einigen Schultheatern gehört, die mit der Freeware Version von Chamsys Arbeiten

Herzlichst Gedankt für Eure Mühe
Rebecca

Traumhaft Ideal - 104 --> 2 SX1509 können das, weil die kannst du an den I2C Bus hängen. Hast dir die beiden Links angesehen?
Toll - 64 --> 1 SX1509 kann das, hast dir den Link angesehen?
OK - 32 --> .... auch das geht mit einem SX1509

Nachdem du dir den SX1509 angesehen hast - welche Frage hättest du zu diesem Chip noch?

Aus meiner sicht solltest du nun schrittweise vorgehen, eins nach dem anderen:

  • ein paar konventionelle Taster auslesen und keystrokes senden
  • einen Encoder auslesen und keystrokes senden
  • mehrere Encoder auslesen und keystrokes senden
  • den Tastersketch und den Encoder Sketch verheiraten
  • den SX1509 (schon wieder dieses Ding...) auslesen
  • den SX1509 auslesen und Keystrokes senden
  • den Encoder-Sketch ergänzen

Als Bauteilliste würde ich vorsehen:

1 Like

Verstehe ich richtig?
also die reine Tastatur über den 1509 läuft
und der encoder über etwas anderes?

Was sind Keystrokes?

UNO hab ich ja schon (bald)

JA, etwas das ich auf Anhieb sofort verstehe...
Ansonsten habe ich immer noch viele Fragezeichen... Leider...

Hallo Rebecca,

104 Tasten geht auch. Dafür bräuchte man dann 2 Stück SX1509 chips.
An die kann man eine pro Stück eine 8x8 Tastenmatrix anschliessen.
8x8 = 64 plus am zweiten SX1509 5x8 Tasten.

Der SX1509 hat 400 kHz Bustakt. Da der SC1509-Chip schon einen Teil der
"Tastendrücke-Erfassen-Arbeit" intern macht müsste das Auslesen der Tastendrücke sehr schnell gehen. 8 Drehencoder mit Drückertaste heißt 3 x 8 = 24 IO-pins. Das könnte noch mit an den zweiten SX1509 dranpassen. Wenn nicht gibt es einen dritten.
Um mal ein bisschen Grundprinzip zum I2C-Bus zu erklären:
DMX ist ja auch ein Bus-System. Auf die Busleitung werden Datenpakete geschickt die die Empfängeradresse mit enthalten.

Hallo SX1509-A sende mir (dem Microcontroller) deine Schaltzustände
Hallo SX1509-B sende mir (dem Microcontroller) deine Schaltzustände
Hallo SX1509-C sende mir (dem Microcontroller) deine Schaltzustände

Und wenn man nicht den SX1509 sondern den MCP23007 nimmt dann wäre es eben
Hallo MCP23007-A sende mir (dem Microcontroller) deine Schaltzustände
Hallo MCP23007-B sende mir (dem Microcontroller) deine Schaltzustände
Hallo MCP23007-C sende mir (dem Microcontroller) deine Schaltzustände
Hallo MCP23007-D sende mir (dem Microcontroller) deine Schaltzustände

Das Abfragen geht so schnell dass man wahrscheinlich ohne Probleme auch noch einen vierten SX1509 dazupacken könnte.

Alte Programmierweisheit: Ein Programm ist niemals fertig. Es ist höchstens lauffähig.

Auch das geht das dazu zu programmieren. Wenn du es so präzise gedrückt kriegst
auch in der Form: Doppelklick innerhalb von 0,3 Sekunden macht Faktor hundert,
Doppelklick innerhalb von 0,6 Sekunden macht ....
Dreifachklick macht dies und das

Und das ist dann die Stelle wo es sich lohnt selber programmieren zu können.
Programm nach den eigenen Vorstellungen umschreiben / erweitern.

Jetzt wollte ich mal bei den Forums-Kollegen nachfragen wie die das einschätzen.
kriegt man mit dem SX1509 auch die Encoder-Abfrage hin?
Er hat einen
PIN 9 NINT DO Active low interrupt output
Deswegen würde ich meinen es müsste gehen.

Zum Schaltplan:
Egal welche Chips nachher verwendet werden. Die ganzen Tasten und Drehencoder kommen an die IO-Pins der IO-Expander-Chips.

Bei Eckstein gibt es ein SX1509-breakout-Board

Im Schaltplan sieht man das die IO-Pins die Anschlüsse mit den Nummern
0 bis 15 sind

Das heißt an den Anschlüssen 0 bis 15 auf dem Breakoutboard werden die Tasten und Drehencoder angeschlossen

Ich finde das ein interessantes Projekt. Hier gibt es - glaube ich - gleich mehrere User
die beim programmieren helfen würden. Ich auch.

Rebecca du kannst wahrscheinlich nicht abschätzen ob du nun 10 Stunden oder 300 Stunden brauchst um genug programmieren zu lernen um es selbst hinzubekommen.

Nun ich schätze mal mit Unterstützung aus dem Forum hast du nach 20 bis 30 Stunden so viel Ahnung dass du kleine Änderungen selbst hinbekommst. Und für alle tiefergehenden Änderungen, Unterstützung bei evtl. Fehlersuche ist das Forum da.

Tastenkombination geht höchstwahrscheinlich auch. Da kenne ich mich mit HID-USB auf Arduinos (noch) nicht gut genug aus.
@The_USB_specialists: geht das: die Tastenkombination Ctrl-Windows-linke-Shift-Taste-AltGR
vom Arduino zu senden?

vgs

1 Like

ich sehe da eigentlich keinen Nutzen Encoder Pins durch eine I2C Kommunikation zu quetschen oder davor vieleicht noch auf einen IC Interrupt zu reagieren bevor der Chip abgefragt wird. Daher würde ich für die Encoder auch keinen SX1509 (aber auch keinen MCP*) vorsehen und die Encoder Pins konventionell auslesen. Ich würde alles pullen, alle Encoder sowie eventuelle Tasten.

damit meinte ich die Simulation einer Tastatureingabe über HID/USB ... also z.B. du drückst die HW-Taste 22, und am PC kommt ein STRG-F1. STRG-F1 wäre dann die keystrokes.

Gemeint sind wohl Tastendruckcodes, also Keyboard.press(Tastendruckcode).

Mit meinem Teensy 3.2 probiert geht Strg+V so:

    Keyboard.press(MODIFIERKEY_CTRL);
    Keyboard.press(KEY_V);
    Keyboard.release(KEY_V);
    Keyboard.release(MODIFIERKEY_CTRL);

@rebel_tilt: Bedenke bitte, daß niemend genau Deine Hardware haben wird. Beispielsweise habe ich zwei Drehgeber, mit denen ich probieren kann, werde aber keine weiteren dazukaufen, um für Dich zu probieren, ob auch acht funktionieren. Das mußt Du dann alleine machen.

Vermutlich bist Du auch in einem halben Jahr noch nicht fertig, bitte überprüfe, ob Dein Geduldsfaden das aushält.

1 Like

Das wird hier erklärt:

https://www.arduino.cc/reference/en/language/functions/usb/keyboard/keyboardmodifiers/

gestern Nachmittag hätte ich das noch nicht so eingeschätzt. Heute weis ich mehr.

Also da gibts schon ein paar Stolperfallen.
1: Debuggen am Micro macht keinen Spaß. Ich habe nun einen separaten TTL-USB Wandler an Serial1 hängen damit ich sehe was da eigentlich passiert


Für die die schon länger mit dem Micro arbeiten vieleicht eh klar, bei mir lag das Teil bisher nur in der Bastelkiste und habe ich jetzt das erste mal so richtig verwendet. Vieleicht wäre ein Teensy doch einfacher in der Handhabung.

2: Debuggen von Keystrokes macht auch keinen Spaß, ich habe da jetzt 3 Fenster offen, die IDE, ein Terminal-Programm und ein Notepad. Das TerminalProgramm damit ich die Debug Ausgaben sehe - sonst müsste ich in der IDE immer zwischen hochladen und programmieren die Ports umschalten. Das Notepad als Müllhalde zum Abfangen der Eingaben - sonst hast auf einmal deine Zeichen im Code ;-(, die IDE zum Programmieren und hochladen (eh klar).

3: man/frau muss sich mit den timeouts/settings spielen. Auch bleibt noch die Definition über, nach welcher Zeit soll eigentlich so ein Keystroke wiederholt an den PC gesendet werden, ist das überhaupt bei jeder Taste gewünscht etc etc

4: der SX1509 hat zwar 5V tolerante Eingänge will aber 3.3V VCC haben. Gibt es auf meinem 5V Micro aber nicht. Gut ich hab ein paar LDO zu Hause (genommen hab ich LP2950 ACZ3.3) und war kein Problem (wenn man ins Datenblatt schaut und richtig rum anschließt), aber das könnte einen bremsen (wenn man eben nichts ins Datenblatt schaut...). Besser also, nach einem 3.3V Micro Ausschau halten.

R: All dem zum Trotz, der Sketch läuft, aber die Euphorie ist ziemlich gewichen. Responsive ist das ganze, da kann ich nichts Negatives feststellen. Die Krücken kann man alle beheben bzw. muss man sich halt Gedanken machen was man genau will.

Dennoch würde eher dazu raten, die "Kassatastatur" weiter zu verwenden, oder eine USB Tastatur zu zerlegen, oder eine programmierbare anzuschaffen für alles was "Taster" sein sollen, besonders wenn es richtung 104 Taster gehen soll. Nicht dass ich weiterhin überzeugt bin, dass das mit zwei SX1509 auch klappt, aber ich glaube nicht, dass man das zu einem kompetitiven Preis im DIY billiger schafft als mit Fertigware. Spätestens bei der Anschaffung guter (leiser?) Taster ist Schluss.

Das mit den Encodern könnte man sich noch anschauen, das macht eventuell noch Sinn weil da habe ich nur wenig Fertigprodukte gesehen. Andererseits gibt es da auch tonnenweise Sketche / Tutorials im Netz, auf youtube ... sodass man sich zweimal überlegen soll ob es sich lohnt das Rad neu zu erfinden.

Naja vieleicht kommt am WE noch was... so long...

1 Like

Ich würde das so angehen:

Das senden von keystrokes separat testen ob das im Prinzip funktioniert.
KLeinbuchstaben, Großbuchstaben
Kombinationen mit Shift- Strg- Alt- WIndows-Taste

Ich habe auf dem XIAO Windows-Alt-l getestet hat auf Anhieb funktioniert

      Keyboard.press(KEY_LEFT_GUI); // windows-Taste
      Keyboard.press(KEY_LEFT_ALT);            
      Keyboard.press('l');

      Keyboard.release('l');
      Keyboard.release(KEY_LEFT_GUI);    
      Keyboard.release(KEY_LEFT_ALT);    

Welcher keystroke dann gesendet wird ist ja nur noch eine andere Kombination von
.press und .release

Dann alle Funktionen außer USB-keystrokes erzeugen testen durch Ausgabe auf den seriellen Monitor
Für die keystrokes wird dann eine entsprechende kurze Zeichenkette ausgegeben
"press/release Win-Alt-l"

Dann kann man den ganzen Rest programmieren ohne die ganze Zeit noch ein Text-Editor-Fenster aufzuhaben. Oder vielleicht sogar einen extra-Microcontroller für die Erzeugung der
keystrokes verwenden.
Der Extra-Microcontroller empfängt auf der seriellen Schnittstelle die Zahlenwerte die den Konstanten entsprechen und die Zahlenwerte werden dann in die passenden .press und .release-Befehle umgesetzt. Die Hardware-seriell-Schnittstelle müsste doch noch höhere Baudraten als 115200 können. Dann kann man es sich leisten beim Senden vier ASCI-digits für jeden key-modifyer und die Taste selbst zu senden.
Also bezogen auf das Beispiel Win-Alt-l

Fantasie-Zahlen die nur das Prinzip erklären sollen

Shif Alt  Strg Win  Tast
0000 0435 0000 1034 0708

Wenn der Wert 0 ist dann bedeutet das key-modifyer ist nicht gedrückt.
Dann hat man eine function die das immer auf die gleiche weise in
Keyboard.press(
Keyboard.release(

umsetzt

Bei 25 byte und 10 bits pro Zeichen braucht das bei 115200 baud
25 * 10 / 115200 = 0,00217 = 2,17 Millisekunden

An der Stelle wäre jetzt in der Tat interessant den Microcontroller danach auszusuchen
gibt es einen µC dessen Code-upload-Mechanismus so schön einfach funktioniert wie Arduino-Uno?

Ich schreibe bewusst so schön einfach funktioniert wie

Also

  • Upload anklicken
  • Upload wird durchgeführt
  • neue Codeversion startet von alleine
  • serielle Schnittstelle ist nach dem Reset sofort wieder verfügbar

Kann das ein Teensy?

vgs

1 Like

Danke für all eure Mühe. Ich bin da wohl etwas schwerfällig

Ah... danke, jetzt habe ich endlich einen Einstieg
Bisher war es für mich eher oft so: ##################Wort############Wort#########Zahl############Wort#####
(#= Fachchinesisch , Wort/Zahl habe ich gelesen, aber meist keinen Zusammenhang erkannt)

Über ADDR0 und ADDR1 kann ich die Platine Numerieren? wie heißt der Anschluß auf der Platine? OSC wird wohl ein Oszillator sein. VCC1 ,VCC2, SDA und SCL, ist mir noch Unklar.
Klasse finde ich das man In oder Out frei wählen kann.

Also beim Leonardo finde ich im Vergleich die 1,11,12,13 nicht
beim SX1509 fehlt die 16 weil es mit 0 anfängt

Verstehe ich richtig, wenn ich ein Scetch schreibe (jetzt kenn ich auch den Namen), werden diese Punkte angesprochen, wenn ich die Platine ändere, kann es sein, dass dieser Punkt gar nicht existiert.
Jede Platine hat ihre stärken, aber einiges ist gleich, gut das hab ich gerafft.
Der Leonardo hat USB an Bord, kann ich jetzt also 1,2,3, ganz viele SX1509 an den Leonardo über I2C Bus Anschließen? Welche Anschlüsse sind das?
Beim Leonardo sehe ich auch A0-A3 sind das 4 Analog Anschlüsse, über die ich z.B. auch Potis Anschließen kann?

Das USB schon dabei, macht mir den Leonardo ja sympatisch.

Gut wir haben jetzt das Buttonbox Programm für alle leserlich, da gibt es jetzt ein paar Fragen:
...wenn ich jetzt also aus dem Scetch für den Leonardo ansehe: 32-FUNCTION-BUTTON-BOX/ARDUINO_BUTTON_BOXV2.ino at master · AM-STUDIO/32-FUNCTION-BUTTON-BOX · GitHub

byte buttons[NUMROWS][NUMCOLS] = {
{0,1,2,3,4},
{5,6,7,8,9},
{10,11,12,13,14},
{15,16,17,18,19},
{20,21,22,23},
};

Dann bestimme ich also eine Anschluß Matrix von 5 X 5 (wobei in der letzten Zeile nur 4sind)?
Das sind also die 24Taster...
Matrix ist klar: Ich definiere 5 Anschlüße für Horizontal und 5 Anschlüße für Vertical
Das macht also 10Anschlüsse auf der Platine dann im Gebrauch.
Werden die HIER definiert?

byte rowPins[NUMROWS] = {21,20,19,18,15};
byte colPins[NUMCOLS] = {14,16,10,9,8};

Dann finde ich aber die Anschlüße 21,20,19,18, nicht auf der Platine... :thinking:
Oder ist das jetzt völlig PfaLsCH? (um das zu betonen habe ich Falsch jetzt völlig Falsch geschrieben :crazy_face:)

rotariesdef rotaries[NUMROTARIES] {
{0,1,24,25,0},
{2,3,26,27,0},
{4,5,28,29,0},
{6,7,30,31,0},
};

Rotaries ist deutlich, hier werden die endlos Regler also angesprochen, hier habe ich noch Probleme zu verstehen... und auch hier : Wo finde ich die Anschlüsse auf der Platine?

Ich muss erst die Anschlüsse kapieren, bevor die Zusammenhänge mit der Programmierung sich mir aufzeigen.

Natürlich

Das hatte ich schon vermutet das jedes Zeichen einen ZahlenWert zugewiesen ist der dann für uns Menschen nur wieder "übersetzt" wird.

Was heißt eigentlich Debuggen wirklich? Immer wieder stoße ich auf das Wort...

Mega Danke für die Mühe

Wäre Cool, aber nicht so schlimm, wenn es weniger sind, aber dafür schnurrend Funktioniert.
Was hätte ich gerne: Page +,Page-, Next head, Prev Head, Locate, ODD, EVEN, Highligt, Single, FAN , ALL, GO
macht 12

25Taster für 10€ sind leicht zu finden, hab da schon etwas gefunden, die wären dann zusammen unter 40€. Klar ist das nichts Hochwertiges. ...und Leise? ist bei Konzerten doch wirklich Egal.

LG Rebecca

ADDR0 und ADDR1 sind Lötpads auf der Rückseite.
OSC brauchst normalerweise nicht.
VCC1 und VCC2 beim Tasten auslesen auch nicht.
SDA geht zum Arduino - das ist die I2C Leitung für DAten
SCL geht zum Arduino - das ist die I2C Leitung für CLock

Schau dir mal die Beschreibung von Sparkfun an, da sind alle wichtigen Anschlüsse erklärt:
https://learn.sparkfun.com/tutorials/sx1509-io-expander-breakout-hookup-guide?_ga=2.259278474.1628026277.1623385708-1510257473.1616259901

"debuggen" kommt von Bug - ein Fehler. debuggen ist also Fehler beheben.

1 Like

Wow Rebecca,

jetzt geht's aber ab. Das finde ich super!
die SX1509 werden mit den Anschlüssen SDA und SCL an den Microcontroller angeschlossen
Das sind die beiden "Bus-Leitungen"
SDA steht für Serial DAta
SCL steht für Serial CLock

Über diese beiden Anschlüsse werden alle Details bereits digital übertragen.
Wenn man jetzt 8 Drehencoder jeden mit Taster anschliessen möchte dann braucht man dafür 8 x 3 = 24 IO-pins
Das ergibt einen weiteren SX1509 wenn man es denn mit SX1509 machen möchte
direktes anschliessen der 8 Drehencoder würde einen Microcontroller mit einer entsprechend großen Anzahl IO-Pins erfordern oder man reduziert die Anzahl der Drehencoder.

Also ich bin der Meinung es spricht mehr dafür alles über SX1509 zu machen.

Sehr schön anschauliche Beschreibung.
Die "Punkte" sind Bohrungen in der Platine in die entweder so eine Stiftleiste
image
oder direkt Kabel eingelötet werden.
Darüber wird der Elektrische Kontakt zum Microcontroller (der kleine schwarze Chip in der Mitte hergestellt.

jeder Microcontroller hat eine gewisse Anzahl an IO-Pins. (Input/Output-Anschlüsse die im Programm entweder als Signal-Eingang oder als Signal-Ausgang konfiguriert werden können.
digitale IO-pins kennen nur
"Spannung ein" = HIGH= 3.3V/5V
und
"Spannung aus"= LOW = 0,0V

Analoge Pins wandeln eine analoge Spannung 0V-3,3V / 0V -5V in Zahlenwerte 0-255 oder 0-1023 um.

Das Buttonbox-Programm ist schon irgendwie eine Grundlage auf der man aufbauen könnte.
Mir persönlich behagt das Programm nicht. Weil das verstehen ziemlich viel Wissen über Programmierung erfordert.

Da muss man jetzt entweder Zeit aufwenden um sich in die Grundlagen des Programmierens im allgemeinen reinzuarbeiten und dann Dinge wie zweidimensionale Arrays zu verstehen

oder man schreibt das Programm "from scratch" und weiß dann dadurch dass man alles selbst entwickelt hat auch genau wie es funktioniert.

Ich bevorzuge die letztere Variante.
Wenn jetzt jemand Lust hat das 32button-box Programm mal eben auf SX1509 umzuschreiben
UND entsprechend viel anfängerfreundliche Erklärungen dazu zu scheiben bitte gerne.

(Meine Vermutung: Wie die anderen User hier darüber denken
Umscheiben? - naja wenn es sein muss
Anfängerfreundliche Erklärungen ? - och nö dann lieber nich

Aber vielleicht täusche ich mich ja
vgs

1 Like

möglicherweise nicht ganz exakt, aber so ähnlich sieht mein Aufbau aktuell aus:
7 Encoder, 64 Taster sollen kein Problem sein:

ich empfehle EINDRINGLICH noch einmal schrittweise vorzugehen. Lies mal ein paar Buttons aus und schick sie zum PC.

Schau dir auch die Buttonbox an - das ist aber so ca Schritt 3 oder 4.
Erst wenn du das hast - mach mit dem SX1509 weiter.

Meinen Demosketch - es ist mehr ein Proof of Concept - kann ich zur Verfügung stellen - aber erst muss ich sehen, dass die ersten Buttons und Encoder bei dir funktionieren.

1 Like

Das sieht auch gut aus. Die im Encoder integrierten Taster könnten auch über einen zweiten SX1509 abgefragt werden.
@noiasca: Mit welcher library machst du das Encoder-abfragen?
Ich habe mit der "Standard-library" encoder.h schlechte Erfahrungen gemacht
sobald man die Drehrichung umkehrt vertut sich diese library und zählt falsch.

vgs

ich hab da vor einer Weile was "eigenes" gemacht. Die Logik ist von dort: Drehgeber – Mikrocontroller.net "Drehgeber mit wackeligem Rastpunkt dekodieren" ich verzichte aber auf Timer und der Code ist Arduinolike in einer Lib. Die Lib habe ich nie veröffentlicht.

Für eine Buttonbox sollte man das vieleicht etwas weiter optimieren, das kommt drauf an was man genau will. Wenns nur ein "Up" --> der Befehl, "Down" --> der Befehl ist, geht da sicher noch was einfacheres.

Meine Antworten überschneiden sich mit den schon gemachten, bin einfach zu langsam :joy:

SX1509 I/O Expander Breakout Hookup Guide sollte viele Deiner Fragen beantworten. Adressauswahl auf der Platinenrückseite, SDA und SCL für I2C-Bus.

Nein, 22 = 4 Stück an einem I2C-Bus. Das steht auf der Rückseite.

Das ist aber ohne SX1509, sondern direkt am Pro Micro.

Pro Micro & Fio V3 Hookup Guide

Das sind die für die Matrix benutzten Pins am Pro Micro:

byte rowPins[NUMROWS] = {21,20,19,18,15}; 
byte colPins[NUMCOLS] = {14,16,10,9,8}; 

Das willst Du aber nicht!

Da muß ich wohl mit ja antworten :roll_eyes:

:smiley:

Mein Vorschlag in dieser Anleitung: Drehimpulsgeber (rotary encoder) KY-040 zur Eingabe

1 Like

Kein LevelShifter für I2C?

nein hab ich nicht. Sparkfun schreibt die Pins seien 5V tolerant und noch brennt er nicht.