Arduino Forum

International => Deutsch => Topic started by: Mendel13 on Jun 10, 2015, 07:51 am

Title: Tasterschaltung
Post by: Mendel13 on Jun 10, 2015, 07:51 am
Hallo Gemeinde!
so ...hab mich jetzt auch endlich entschlossen, mich mit arduino zu beschäftigen. learning by doing ...
Bin blutiger anfänger, was programmierung angeht. aber ich kämpfe mich durch!!
solide grundkenntnisse elektronik sind vorhanden ... das macht den mc sehr spannend für mich...

manchmal ist ein problem aber mit einem problem verknüpft, nämlich: wie frage ich blöd?!?

ich suche zum verstehen eine tasterchaltung ... und weiss nicht wie man die nennt ...

ich nenns mal: radio-taster ... wie beim radio, senderspeicher: ich habe eine anzahl taster und genau die gleiche anzahl funktionen, hier nenn ichs led's. taster 1 bringt led 1 zum leuchten. taster 2 => led 2, löscht dabei alle anderen led's wieder etc. Einschaltzustand: led1 = on.

wie nennt sich für die suche mal prinzipiell so ne schaltung?

ich würd gern mit dem uno experimentieren und -sofern möglich- die sache auf nen kleineren attiny übertragen.

würde mich über anschubser sehr freuen,

grüße, der mendel
Title: Re: Tasterschaltung
Post by: ronald_paul on Jun 10, 2015, 09:45 am
Hi,

schau mal hier (https://www.youtube.com/user/IMDFHTrier). Da findest Du super Tutorials in deutsch und so erklärt das man es auch versteht.
Unter anderen auch einen Lösungsansatz für Dein Tasterproblem (https://www.youtube.com/watch?v=B5AbaAGCbQ8)!

Grüße,
Ron
Title: Re: Tasterschaltung
Post by: Doc_Arduino on Jun 10, 2015, 03:49 pm
Hallo,

folgende Themen werden dich damit beschäftigen.
Wie entprelle ich einen Taster,
Programmlogik entwerfen, was soll alles wann und wie gemacht werden,
keine festen delay() verwenden, gleich mit millis() usw. anfangen
und daran denken das der µC ohne Pause die loop durchläuft
Title: Re: Tasterschaltung
Post by: agmue on Jun 10, 2015, 08:51 pm
Eine Frage kann man eigentlich erst dann richtig formulieren, wenn man die Antwort kennt! Diese Erkenntnis hast Du mit Wissenschaftlern gemein.

Als ich Deine Frage laß, mußte ich an mein altes Röhrenradio denken:
(http://forum.arduino.cc/index.php?action=dlattach;topic=328913.0;attach=128958)

Vor meinem geistigen Auge hat jeder Taster (INPUT_PULLUP) eine Statusvariable mit dem letzten bekannten Status, der dann mit dem aktuellen verglichen wird, um eine Veränderung festzustellen (Flankenerkennung):

if (alterStatusTaster1 == HIGH && digitalRead(pinTaster1 == LOW) {
 // LED1 an, alle anderen aus
} else if ...

So in der Art.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 12, 2015, 07:42 am
Ja ... tatsächlich hatte ich bei der Beschreibung ein altes Grundig-AutoRadio im Sinn, das ähnliche Bedingung hatte ...

Danke schonmal für die Tipps, werd mich auf die Suche machn auf Programmcodes, wo die Funktion so enthalten sein mag. Hab ehrlich ein wenig Schwierigkeiten, aus der Theorie neu zu lernen ... bisher hats gut geklappt, aus Betrachten und nachbauen von schon existierenden Projekten die Funktion zu verstehen und den aha! -Effekt auszulösen ... und über abändern oder Neu-Schaffung das so zu schaffen, wie ichs mir vorstelle.


grüsse, der Mendel
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 22, 2015, 09:11 am
Hallo,

was haltet Ihr von dem sketsch :-)

Code: [Select]
int t01 = LOW; // setze die Variable mit Namen "t01" und gib ihr den Wert LOW
int t02 = LOW;
int t03 = LOW ;
int t04 = LOW;

void setup() {
  pinMode(14, INPUT); // Pin 14 = A0 ist Eingang für Taster, PullDown
  pinMode(15, INPUT);
  pinMode(16, INPUT);
  pinMode(17, INPUT);
  pinMode(13, OUTPUT); // Pin13 .. als Ausgang
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  digitalWrite(13, HIGH); // Programmstart Pin 13 auf HIGH


}

void loop() {
  t01 = digitalRead(14); // setze Var. t01-04 gleich dem Eingangspegel
  t02 = digitalRead(15);
  t03 = digitalRead(16);
  t04 = digitalRead(17);


  if (t01 == HIGH)  { // wenn t01 gleich HIGH dann...
    digitalWrite(13, HIGH); // setze Pin 15 auf HIGH ... und alle anderen auf LOW
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
    delay(1000);
  
  }
  if (t02 == HIGH) {
    digitalWrite(13, LOW);
    digitalWrite(12, HIGH);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
    delay(1000);
  }
  if (t03 == HIGH) {
    digitalWrite(13, LOW);
    digitalWrite(12, LOW);
    digitalWrite(11, HIGH);
    digitalWrite(10, LOW);
    delay(1000);
  }
  if (t04 == HIGH) {
    digitalWrite(13, LOW);
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, HIGH);
    delay(1000);
  }

}



mal von entprellung abgesehen, soweit funktioniert es.
das ganze wird erweitert auf 7 taster...
ist primitiv ... anderer lösungsweg, was meint ihr?
Title: Re: Tasterschaltung
Post by: Doc_Arduino on Jun 22, 2015, 11:35 am
Hallo,

ohne zu wissen was es machen soll, kann dazu niemand was sagen. Es kann für die Aufgabe reichen. Aber ich denke durch die delays wirst Du irgendwann merken das es nicht immer so reagiert wie gewünscht.

Title: Re: Tasterschaltung
Post by: TelosNox on Jun 22, 2015, 02:47 pm
Mit folgendem Schnipsel kannst du das einfacher schreiben. Du musst aber die LEDs anders mappen.
Button 14 -> Led 10
Button 15 -> Led 11
Button 16 -> Led 12
u.s.w.

dadurch entsteht die Regel: Led = Button - 4

Der Code ist nicht getestet, sollte aber die grundsätzliche Idee verdeutlichen
Code: [Select]

int activeChannel = 0;

void loop() {
  boolean buttonPressed = false;
  for (int pin = 14; i<= 17; i++) {
    if (digitalRead(pin) == HIGH) {
      activeChannel = pin;
      buttonPressed = true;
      break;
    }
  }

  if (buttonPressed) {
    int activeLed = activeChannel - 4;
    for (int pin = 10; i<= 13; i++) {
      if (pin == activeLed) {
        digitalWrite(pin, HIGH);
      } else {
        digitalWrite(pin, LOW);
      }
    }
  }
}


In activeChannel steht immer der zuletzt gedrückte Button drin. So kannst du dann jederzeit abhängig davon irgendwas anderes steuern.
Title: Re: Tasterschaltung
Post by: Serenifly on Jun 22, 2015, 02:50 pm
@TelosNox

Bei sowas packt man die Pins besser in ein Array. Dann ist die eigentliche Belegung egal, da man über die Array Indices iterieren kann
Title: Re: Tasterschaltung
Post by: TelosNox on Jun 22, 2015, 03:04 pm
Damit wirds dann flexibler, da hast du recht.
Worauf ich im Endeffekt rauswollte war die Nutzung der Schleife.
Ob man jetzt implizit mappt (so wie im Beispiel), das Mapping in ein Array packt oder ob man sich ne kleine Klasse für das Mapping schreibt und davon dann X Objekte in ein Array packt und das dann iteriert oder sonst noch wie ist dann der andere Schuh.

Erstmal muss diese ungemein hohe Redundanz weg.

Ich hab nur die Befürchtung, dass Mendel das Konstrukt sowieso nicht so leicht durchblickt (hat ja geschrieben, dass er Anfänger ist). Aber dann kann er ja hier weiter nachhaken
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 22, 2015, 03:30 pm
hey leute ... danke für das feedback.

ja .. anfänger ... blutiger ...

was es machen soll: hier im versuch erst mal nur LED leuchten lassen, unabhängig was jemals dahinter angesteuert wird.
die delays kamen mir in sinn für eine gewisse "entschärfung" ... werden aus versehen zwei taster gedrückt, leuchten auch beide LEDs im takt des void-loops.

ok, für mich ein erfolgserlebnis wenn auch primitiv ... es macht mit 4 LEDs mal das wie ichs vorgestellt hab.

Quote
Ich hab nur die Befürchtung, dass Mendel das Konstrukt sowieso nicht so leicht durchblickt (hat ja geschrieben, dass er Anfänger ist). Aber dann kann er ja hier weiter nachhaken
äh ... jupp. aber setzen wir das wörtchen "noch" nach "sowieso" ... ok?
Title: Re: Tasterschaltung
Post by: TelosNox on Jun 22, 2015, 04:00 pm
Dass das ein "noch" ist, sollte selbstverständlich sein, wir wollen dir ja weiterhelfen und dir ja was beibringen.

Was das Tasterprellen angeht: Solange du nur eine Umschaltung brauchst und es nicht drauf ankommt, wie oft ein Knopf gedrückt wurde, dann kann dir das Prellen egal sein. Ob du jetzt den aktiven Kanal (ich nenne das mal so, analog zum Radio Beispiel) 1x auf die 3 setzt oder 10x auf die 3 ist ja egal, solange da nicht gleichzeitig noch irgend was anderes ausgelöst wird.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 22, 2015, 05:54 pm
danke ... *schnüff* ... bin gerührt ....

das dachte ich mir auch ... ob der taster gschwind 50x durchs prellen "gedrückt" wird sollte hier wurscht sein. es war eben nur die situation, dass bei zwei tastern drücken auch die entsprechenden leds leuchten. durchs delay ist das soweit eliminiert.

ok ... ich werd mich mal an die wirkungsweise der arrays machen und boolean ...
Title: Re: Tasterschaltung
Post by: agmue on Jun 22, 2015, 05:55 pm
Hallo, kleine formale Bitte, Deinen Code in Codetags zu setzen, geht mit dem Button </>.

die delays kamen mir in sinn für eine gewisse "entschärfung" ... werden aus versehen zwei taster gedrückt, leuchten auch beide LEDs im takt des void-loops.
Mein etwas einfacher gestrickter Vorschlag (ungetestet):
Code: [Select]
if (t01 == HIGH)  { // wenn t01 gleich HIGH dann...
    digitalWrite(13, HIGH); // setze Pin 15 auf HIGH ... und alle anderen auf LOW
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
  }
  else if (t02 == HIGH)
  {
    digitalWrite(13, LOW);
    digitalWrite(12, HIGH);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
  }
  else if (t03 == HIGH)
  {
    digitalWrite(13, LOW);
    digitalWrite(12, LOW);
    digitalWrite(11, HIGH);
    digitalWrite(10, LOW);
  }
  else if (t04 == HIGH)
  {
    digitalWrite(13, LOW);
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, HIGH);
  }

Über else hast Du eine Priorisierung für die Taste mit der niedrigeren Nummer und kein Blinken.
Title: Re: Tasterschaltung
Post by: agmue on Jun 22, 2015, 06:00 pm
Code: [Select]
int t01 = LOW; // setze die Variable mit Namen "t01" und gib ihr den Wert LOW
int t02 = LOW;
int t03 = LOW ;
int t04 = LOW;

 Da diese Variable nur zwei Zustände haben kann, würde boolean t01 = LOW reichen. Spart vier Byte  :) ist aber auch deutlicher in der Aussage.
Title: Re: Tasterschaltung
Post by: combie on Jun 22, 2015, 06:13 pm
Quote
Spart vier Byte
Code: [Select]
struct LedZustand
{
    bool Led00:1;
    bool Led01:1;
    bool Led02:1;
    bool Led03:1;
    bool Led04:1;
    bool Led05:1;
    bool Led06:1;
    bool Led07:1;
};
LedZustand Leds ;

// ---- Verwendung:
 Leds.Led04 = LOW;
// ----



Spart nochmal 3 Byte
Title: Re: Tasterschaltung
Post by: agmue on Jun 22, 2015, 06:28 pm
Mir wurde hier im Forum geschrieben, vor der Verwendung von structs müßte ich noch viiiiiiiel lernen, darum hatte ich dieses Thema bisher umgangen. Dein Beispiel erklärt sich ja von selbst, könnte ein Einstieg sein.  :)
Title: Re: Tasterschaltung
Post by: Serenifly on Jun 22, 2015, 06:35 pm
Das ist mehr als einfaches struct. Nämlich ein Bitfeld:
http://www.c-howto.de/tutorial-strukturierte-datentypen-bitfelder.html (http://www.c-howto.de/tutorial-strukturierte-datentypen-bitfelder.html)

Sieht man recht selten.
Title: Re: Tasterschaltung
Post by: combie on Jun 22, 2015, 06:44 pm
Mir wurde hier im Forum geschrieben, vor der Verwendung von structs müßte ich noch viiiiiiiel lernen ...
Och...
Das würde ich nicht sagen.
"Struct bringt (Daten)Struktur ins Projekt!"
Das kann man nicht früh genug verstehen.
Die Feinheiten kommen durch Übung.
Title: Re: Tasterschaltung
Post by: agmue on Jun 22, 2015, 07:10 pm
Die Feinheiten kommen durch Übung.
Ich zähle auf Dich!

Dann hier mein "structurierter" Vorschlag (ungetestet, aber mein Compiler ist einverstanden):
Code: [Select]
struct LedZustand
{
  bool Led00: 1;
  bool Led01: 1;
  bool Led02: 1;
  bool Led03: 1;
  bool Led04: 1;
  bool Led05: 1;
  bool Led06: 1;
  bool Led07: 1;
};
LedZustand Leds ;

void setup() {
  pinMode(14, INPUT); // Pin 14 = A0 ist Eingang für Taster, PullDown
  pinMode(15, INPUT);
  pinMode(16, INPUT);
  pinMode(17, INPUT);
  pinMode(13, OUTPUT); // Pin13 .. als Ausgang
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  digitalWrite(13, HIGH); // Programmstart Pin 13 auf HIGH
}

void loop() {
  Leds.Led01 = digitalRead(14); // setze Var. t01-04 gleich dem Eingangspegel
  Leds.Led02 = digitalRead(15);
  Leds.Led03 = digitalRead(16);
  Leds.Led04 = digitalRead(17);


  if (Leds.Led01 == HIGH)  { // wenn t01 gleich HIGH dann...
    digitalWrite(13, HIGH); // setze Pin 15 auf HIGH ... und alle anderen auf LOW
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
  }
  else if (Leds.Led02 == HIGH)
  {
    digitalWrite(13, LOW);
    digitalWrite(12, HIGH);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
  }
  else if (Leds.Led03 == HIGH)
  {
    digitalWrite(13, LOW);
    digitalWrite(12, LOW);
    digitalWrite(11, HIGH);
    digitalWrite(10, LOW);
  }
  else if (Leds.Led04 == HIGH)
  {
    digitalWrite(13, LOW);
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, HIGH);
  }
}
Title: Re: Tasterschaltung
Post by: TelosNox on Jun 22, 2015, 08:24 pm
Steht ihr alle auf redundanten Code oder gehts um das einfachere Verständnis?

Hier nochmal die Variante mit dem Struct, aber deutlich kürzer. Eine Boolsche Variable braucht man übrigens nicht auf true prüfen
if (var == true)
das passiert automatisch und es reicht
if (var)

Hier das Sketch von agmue mit der Änderung
Code: [Select]

struct LedZustand
{
  bool Led00: 1;
  bool Led01: 1;
  bool Led02: 1;
  bool Led03: 1;
  bool Led04: 1;
  bool Led05: 1;
  bool Led06: 1;
  bool Led07: 1;
};
LedZustand Leds ;

void setup() {
  pinMode(14, INPUT); // Pin 14 = A0 ist Eingang für Taster, PullDown
  pinMode(15, INPUT);
  pinMode(16, INPUT);
  pinMode(17, INPUT);
  pinMode(13, OUTPUT); // Pin13 .. als Ausgang
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  digitalWrite(13, HIGH); // Programmstart Pin 13 auf HIGH
}

void loop() {
  Leds.Led01 = digitalRead(14);
  Leds.Led02 = digitalRead(15);
  Leds.Led03 = digitalRead(16);
  Leds.Led04 = digitalRead(17);


  if (Leds.Led01 || Leds.Led02 || Leds.Led03 || Leds.Led04)  { // wenn irgend ein Button auf HIGH ist
    digitalWrite(13, Leds.Led01);
    digitalWrite(12, Leds.Led02);
    digitalWrite(11, Leds.Led03);
    digitalWrite(10, Leds.Led04);
  }
}
Title: Re: Tasterschaltung
Post by: michael_x on Jun 23, 2015, 02:54 pm
Quote
Steht ihr alle auf redundanten Code
Also bei mir macht das keinen Unterschied ob ich
if (boolvar)
oder
if (boolvar == HIGH)
schreibe. Der Code hat die gleiche Größe.
Getestet mit einer bool Variable, die nur 1 Bit in einer struct groß ist
Title: Re: Tasterschaltung
Post by: combie on Jun 23, 2015, 03:04 pm
Schön; der Optimierer erkennt die sinnfreie Aktion.
Was dann umso klarer macht, dass sie sinnfrei ist.
 8)  8)  8)
Title: Re: Tasterschaltung
Post by: Serenifly on Jun 23, 2015, 03:14 pm
Sinnfrei ist es nicht. Ich finde es macht den Code manchmal etwas einfacher lesbar, da man vielleicht eher sieht was gemeint ist. Gerade für Anfänger. Ich kann mich aber nicht wirklich entscheiden welche Schreibweise ich bevorzuge. Bei einer Abfrage auf true ist es egal, aber ich finde var == false besser lesbar als !var

Ansonsten ist das aber reine Geschmackssache
Title: Re: Tasterschaltung
Post by: TelosNox on Jun 23, 2015, 04:24 pm
Steht ihr alle auf redundanten Code oder gehts um das einfachere Verständnis?

Hier nochmal die Variante mit dem Struct, aber deutlich kürzer...
@michael_x
Gemeint war NICHT das weglassen von == HIGH, sondern die Verkürzung durch weglassen des if/else if/else if etc...
Du solltest schon den Code lesen, den ich poste  ;)
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 23, 2015, 06:21 pm
okokokok .... das ist viel input grad ... wenn ich nicht gleich dazusenfe bitte nicht als undank ansehen ... ich kopfe nur darüber und freu mich wirklich über euer output ....

also die codes funzen alle. bis auf eines: das bei zwei (versehentlich gleichzeitig) gedrückten tasten auch die beiden entsprechenden funktionen (hier die LEDs) ON sind.

nun muss ich aber erst mal die befehle bool und struct verinnerlichen  :o
und was das auf deutsch heissen soll:
digitalWrite(13, Leds.Led01);
setze Pin 13 auf den wert Leds.Led01 ... aber was ist Leds.Led01?? eine variable ... mit nem "." dazwischen? und hängt mit dem befehl "bool Led01: 1;" zusammen?

ok ... in den krampf ... äh ... kampf :-)

Title: Re: Tasterschaltung
Post by: combie on Jun 23, 2015, 06:26 pm
Schön, wenn es dir gefällt!

Quote
nun muss ich aber erst mal die befehle bool und struct verinnerlichen  :o
und was das auf deutsch heissen soll:
digitalWrite(13, Leds.Led01);
setze Pin 13 auf den wert Leds.Led01 ... aber was ist Leds.Led01?? eine variable ... mit nem "." dazwischen? und hängt mit dem befehl "bool Led01: 1;" zusammen?
Genau!
In der Variablen Leds steckt eine Datenstruktur namens LedZustand.
Und darin steckt eine 1 Bit große Variable namens Led01

Und den PunktOperator solltest du schon kennen, aus:
Code: [Select]
Serial.begin(9600);


Title: Re: Tasterschaltung
Post by: Serenifly on Jun 23, 2015, 06:50 pm
bool ist mein Befehl, sondern ein Datentyp. Wie int oder long

Das mit dem struct und :1 ist ein Bitfeld. Dadurch kann der Compiler direkt einzelne Bits in einer Variable ansprechen ohne dass man den Code dazu selbst schreiben muss. Man belegt also nicht 8 Bit für einen Zustand, sondern in diesem Fall nur 1 Bit.

Siehe den Link oben:
http://www.c-howto.de/tutorial-strukturierte-datentypen-bitfelder.html (http://www.c-howto.de/tutorial-strukturierte-datentypen-bitfelder.html)

Ist aber für Anfänger etwas weit ausgeholt. Man braucht das nicht. Spart lediglich Speicher.
Title: Re: Tasterschaltung
Post by: TelosNox on Jun 23, 2015, 06:56 pm
und was das auf deutsch heissen soll:
digitalWrite(13, Leds.Led01);
Mit Leds.Led01 erhältst du den Wert, der gerade Leds.Led01 zugewiesen ist.
Weiter oben im Code machst du ja Leds.Led01 = digitalRead(14);
Somit setzt du Leds.Led01 auf den Wert, den dir digitalRead(14) geliefert hat (also HIGH falls Taster gedrückt und LOW, falls nicht gedrückt).

Du machst mit digitalWrite(13, Leds.Led01) also nichts anderes, als die LED auf den Zustand zu setzen, den der Taster zum Zeitpunkt des Auslesens hatte.
Title: Re: Tasterschaltung
Post by: michael_x on Jun 23, 2015, 08:49 pm
@TelosNox:
Ich habe mich hierauf bezogen:
Quote
Hier nochmal die Variante mit dem Struct, aber deutlich kürzer. Eine Boolsche Variable braucht man übrigens nicht auf true prüfen
if (var == true)
das passiert automatisch und es reicht
if (var)
Schön, dass wir uns mit der Optimierung durch den Compiler einig sind.

Wenn dein Code auch noch eher das macht als was im Original programmiert war, auch gut.
Dafür spricht der seltsame Kommentar "// setze Var. t01-04 gleich dem Eingangspegel"
Genaugenommen macht er aber was anderes, wenn mehr als ein Bit gesetzt ist. Bei agmue und Mendel13 leuchten immer nur eine LED. ( unterschiedliche  ;) )
pinMode(14, INPUT) ; ist übrigens wirklich redundant.

@Mendel13: Danke für deinen Thread, den wir gerne missbrauchen.
Einen 328 kriegst du mit solchen Aufgaben nicht überlastet, ist also vollkommen egal, wie "redundant" du programmierst. Ein Sketch der das macht was er soll, ist immer gut ;)
Title: Re: Tasterschaltung
Post by: TelosNox on Jun 23, 2015, 08:59 pm
michael mir ist klar, dass meine Variante keinen wechselseitigen Ausschluss enthält, der war aber auch nicht explizit gefordert (zumindest hab ichs nicht so verstanden). Wenn man damit umgehen will, dass mehrere Taster zugleich gedrückt sein können und dann trotzdem nur einer Aktiv sein soll, dann muss man z.B. die Variante nehmen, die ich ganz am Anfang gepostet habe (eine Variable auf den aktiven Kanal setzen und die Variable dann auswerten).
Oder man arbeitet beim lesen der Pins mit XOR, um einen eindeutigen Kandidaten zu erhalten (da wirds aber mit steigender Anzahl der Taster schnell dreckig).

Code: [Select]

  Leds.Led01 = digitalRead(14);
  Leds.Led02 = digitalRead(15) ^ Leds.Led01;
  Leds.Led03 = digitalRead(16) ^ Leds.Led01 ^ Leds.Led02;
  Leds.Led04 = digitalRead(17) ^ Leds.Led01 ^ Leds.Led02 ^ Leds.Led03;


Sowas wird Mendel aber im Moment vermutlich maßlos überfordern.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 24, 2015, 06:35 am
ist "bool" die kurzform von "boolean" ?
Title: Re: Tasterschaltung
Post by: TelosNox on Jun 24, 2015, 08:08 am
Das ist die Syntax dafür und bedeuted boolean, ja. Wenn du boolean schreiben würdest, dann meckert der compiler.
Title: Re: Tasterschaltung
Post by: combie on Jun 24, 2015, 08:42 am
Das ist die Syntax dafür und bedeuted boolean, ja. Wenn du boolean schreiben würdest, dann meckert der compiler.
Meiner nicht.
Und schaut man in die Tiefen, dann wird man sehen, dass boolean ein alias von bool ist.
Quote
Code: [Select]
typedef bool boolean;
In Arduino.h
Title: Re: Tasterschaltung
Post by: Serenifly on Jun 24, 2015, 09:00 am
ist "bool" die kurzform von "boolean" ?
Jein.

Der C++ Datentyp ist bool. In der Arduino IDE hat man das wahrscheinlich boolean genannt damit es identisch zu Processing ist, was auf Java basiert und dort heißt es boolean.

Neuerdings ist es das gleiche. Seit ein neueren IDE Version ist boolean ein Alias (typedef) von bool. Das war leider nicht immer so. Am Anfang war das idiotischerweise ein Alias von unsigned char (was in C vor dem C99 Standard üblich war). Das heißt man konnte einem boolean einen Wert > 1 zuweisen und den hat er behalten. Das macht einen Unterschied wenn man einen boolean der > 1 ist mit true verglichen hat. Da das natürlich nicht wahr ist. Mit bool hat man dieses Problem nicht. Dem kann man auch Werte > 1 zuweisen und der Compiler korrigiert das automatisch.

Aber wenn du eine aktuelle Version hast ist bool wie gesagt identisch zu boolean.
Title: Re: Tasterschaltung
Post by: TelosNox on Jun 24, 2015, 09:55 am
Interessant, ich hatte compile Fehler wegen boolean (oder ich hatte bool keine Ahnung mehr) und nachdem ich es auf die andere Variante geändert hatte, ging es dann.
Allerdings benutze ich nicht die IDE, sondern Eclipse mit Plugin.
Vielleicht wars aber auch so, dass an der betreffenden Stelle die Arduino.h noch gar nicht includiert war. Das könnte es erklären.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 24, 2015, 01:30 pm
verstehe ich richtig:
bool(ean)  setzt wie int eine variable, nur dass es keine ganzzahl ist (wie bei int +-32.schiessmichtot) sondern "nur" 1 oder 0 bzw. true / false ?
Title: Re: Tasterschaltung
Post by: TelosNox on Jun 24, 2015, 01:32 pm
So ist es. Ein boolean ist ein reiner Wahrheitswert bzw. einfach ein Schalter mit "ein" und "aus".
Title: Re: Tasterschaltung
Post by: Serenifly on Jun 24, 2015, 01:34 pm
Bei den neueren Arduino Versionen stimmt das.

Bei den alten stimmt es nur für bool, und boolean ist statt dessen nichts anderes als ein unsigned char (d.h. das gleiche wie byte).

Das wurde in 1.6.0rc2 geändert:
Quote
Arduino "boolean" type is now mapped to "bool" instead of "uint8_t" (Christopher Andrews)
Das ist vielleicht verwirrend. Aber der Unterschied ist da. Bei boolean als unsigned char statt bool, macht das nicht was man vielleicht denkt:
Code: [Select]

boolean var = 10;
if (var == true)
{
}

Das passt dagegen:
Code: [Select]

boolean var = 10;
if (var)
{
}


Das ist ein Grund weshalb ich vorher schon immer bool verwendet habe. Ab 1.6.0 trifft das wie gesagt nicht mehr zu. Das ist auch genau der Grund weshalb es geändert wurde.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 24, 2015, 01:44 pm
ich bin verwirrt, sorry ...

Quote
So ist es. Ein boolean ist ein reiner Wahrheitswert bzw. einfach ein Schalter mit "ein" und "aus".
Quote
boolean var = 10;
???
Title: Re: Tasterschaltung
Post by: Serenifly on Jun 24, 2015, 02:00 pm
Allgemein ist 0 false und alles was ungleich 0 ist true. Wenn man sowas macht:
Code: [Select]

if (var)

Das Problem ist jetzt dass wenn man == true oder == false schreibt, true da wirklich nur 1 ist.

Und es gibt Anwendungen wo man einem bool eine Zahl größer als 1 zuweist. Bei einem richtigen bool (oder ab 1.6.0 auch boolean) wird der Wert dann automatisch auf 1 gekürzt.

Das wird für dich nicht relevant sein, aber es gibt ein paar solcher Feinheiten wo man da schnell reinfällt. Für die meisten Anwendungen wird man da aber nur true/false oder HIGH/LOW zuweisen, welche nur 0/1 sind.


Oder kürzer:
Vor 1.6.0 gibt es einen feinen Unterschied zwischen bool und boolean. Ab 1.6.0 ist es das Gleiche.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 24, 2015, 06:43 pm
"Allgemein ist 0 false und alles was ungleich 0 ist true."

so ists dann klar. verwirrung beseitigt.
Title: Re: Tasterschaltung
Post by: agmue on Jun 25, 2015, 09:30 pm
Bin blutiger anfänger, was programmierung angeht. aber ich kämpfe mich durch!!
Spart vier Byte  :) ist aber auch deutlicher in der Aussage.
Steht ihr alle auf redundanten Code oder gehts um das einfachere Verständnis?
Ich habe mit meiner Bemerkung zum Sparen von Bytes versehendlich einen Wettbewerb ausgelöst. Das war nicht in meiner Absicht, auch wenn das Ergebnis (struct und XOR) für mich durchaus interessant geworden ist. Einem "blutigen Anfänger" nützt ein perfektes Programm nichts, wenn er weit davon entfernt ist, es zu verstehen. Den Fragesteller dort abzuholen, wo er steht, war mein Versuch.

Mir ging es um den Unterschied zwischen Konstanten und Variablen, sowie um die bewußte Wahl eines Variablentyps. Ignoriert man diesen Punkt, kann man schnell ins Stolpern geraten.

Mal sehen, was aus den "Radiotasten" wird.
Title: Re: Tasterschaltung
Post by: TelosNox on Jun 25, 2015, 09:33 pm
agmue daher fragte ich ja, ob die Beispiele wegen dem Verständnis redundant geschrieben sind.

Ich frage mich halt immer: Versuche ich dem Anfänger auch gleich ordentliches Coden beizubringen oder versuche ich es so verständlich wie nur möglich zu machen (auch wenn dann haufenweise redundanter Code entsteht).

Um Bytes sparen gehts mir übrigens nicht, lediglich um die Lesbarkeit (nicht gleichzusetzen mit Verständlichkeit) und die Wartbarkeit.

Ich denke Mendel muss jetzt erstmal ein wenig rumspielen, so lernt er am schnellsten und wenn dann die konkreten Fragen wieder auftauchen, wird er sich melden.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 26, 2015, 06:44 am
leute so wie ihrs macht ists ok. klar mach ichs umständlich ... speicherintensiv ... wenn ichs rennen lernen will muss ich erst lernen, die kackwindel -eine zeit notwendigen übels- wegzulassen ;-)

ich hab den code soweit fertig -redundant aber tut- , löte das zeugs grad auf lochraster.

werde ihn hier reinstellen und dann könnt ihr ihn ja zerreissen, bitte nicht mich  :smiley-confuse:

wie gesagt: trockene theorie ist gift für mich. aber anhand der praxis vertehe ichs. hm. bis jetzt wars zumindest so ...

ich werd noch ne gute zeit hier sein ... mir schwirrt eine pwm-pumpensteuerung mit drucksensor im kopp rum ... da kommt die tastersteuerung irgendwann auch dazu ... aber die tasten sind für mich ne gute einstiegsdroge.

dickes lob an euch. ihr geht gut respektvoll mit mir frischling um. ich hoffe auf nen stand zu kommen, bei dem ich nem anderen das "zurückbezahlen" kann. thx
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 26, 2015, 10:35 am
Sooo ... hier mal der redundante Code, der soweit funktioniert ...


Code: [Select]



int t01 = LOW; // setze die Variable mit Namen "t01" und gib ihr den Wert LOW
int t02 = LOW;
int t03 = LOW;
int t04 = LOW;
int t05 = LOW;
int t06 = LOW;
int minus = LOW;
int plus = LOW;
int man = LOW;

void setup() {
  //pinMode(14, INPUT); // Pin 14 = A0 ist Eingang für Taster, PullDown
  //pinMode(15, INPUT);
  //pinMode(16, INPUT);
  //pinMode(17, INPUT);
  pinMode(13, OUTPUT); // Pin13 .. als Ausgang
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(5, INPUT);
  pinMode(4, INPUT);
  digitalWrite(13, HIGH); // Programmstart Pin 13 auf HIGH


}

void loop() {
  t01 = digitalRead(14); // setze Var. t01-04 gleich dem Eingangspegel
  t02 = digitalRead(15);
  t03 = digitalRead(16);
  t04 = digitalRead(17);
  t05 = digitalRead(18);
  t06 = digitalRead(19);
  man = digitalRead(8);
  minus = digitalRead(5);
  plus = digitalRead(4);


  if (t01 == HIGH)  { // wenn t01 gleich HIGH dann...
    digitalWrite(13, HIGH); // setze Pin 15 auf HIGH ... und alle anderen auf LOW
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
    digitalWrite(9, LOW);
    digitalWrite(8, LOW);
  }
  else if (t02 == HIGH)
  {
    digitalWrite(13, LOW);
    digitalWrite(12, HIGH);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
    digitalWrite(9, LOW);
    digitalWrite(8, LOW);
  }
  else if (t03 == HIGH)
  {
    digitalWrite(13, LOW);
    digitalWrite(12, LOW);
    digitalWrite(11, HIGH);
    digitalWrite(10, LOW);
    digitalWrite(9, LOW);
    digitalWrite(8, LOW);
  }
  else if (t04 == HIGH)
  {
    digitalWrite(13, LOW);
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, HIGH);
    digitalWrite(9, LOW);
    digitalWrite(8, LOW);
  }
  else if (t05 == HIGH)
  {
    digitalWrite(13, LOW);
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
    digitalWrite(9, HIGH);
    digitalWrite(8, LOW);
  }
  else if (t06 == HIGH)
  {
    digitalWrite(13, LOW);
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
    digitalWrite(9, LOW);
    digitalWrite(8, HIGH);
  }

  if ((man == HIGH) && (minus == HIGH))
  {
    do
    {
      //delay(50);
      digitalWrite(7, HIGH);
    }
    while (minus == LOW);
    delay(20);
    digitalWrite(7, LOW);
  }
  if ((man == HIGH) && (plus == HIGH))
  {
    do
    {
      //delay(50);
      digitalWrite(6, HIGH);
    }
    while (plus == LOW);
    delay(20);
    digitalWrite(6, LOW);
  }

}







edit:

Nochmals zur verwünschten Funktion:
Mit 6 Tastern sollen 6 Funktionen angeschaltet werden (Im Versuch LEDs), die sich gegenseitig löschen ("Röhrenradio"). Pin13 soll als Start gleich eingeschaltet sein.

die 6. Funktion hat ne Sonderstellung. Ist sie aktiviert sollen LED 7 oder 8 leuchten, solange die Taster 7 oder 8 gedrückt werden, zusammen mit LED (Funktion) 6 . Sind andere LEDs an (1-5) sind 7, 8 ohne Funktion.






Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 26, 2015, 10:39 am
... und hier der Aufbau ...

Hab dat janze auf nen 168er geladen, funzt mal soweit super.
Title: Re: Tasterschaltung
Post by: TelosNox on Jun 26, 2015, 12:20 pm
Code: [Select]

  if ((man == HIGH) && (minus == HIGH))
  {
    do
    {
      //delay(50);
      digitalWrite(7, HIGH);
    }
    while (minus == LOW);
    delay(20);
    digitalWrite(7, LOW);
  }

Erklär mal bitte kurz, was dieser code machen soll (also was du damit vorhast). Ich vermute nämlich, dass er nicht das macht, was du willst.

1. Willst du, dass MAN gleichzeitig gedrückt werden muss oder willst du, dass man den manuellen Modus aktiviert (1x tastern) und dann die plus und minus tasten funktionieren. Aktuell muss der Button gleichzeitig gedrückt sein.

2. Soll der Ausgang für Minus so lange auf HIGH sein, bis man den Taster loslässt (so interpretiere ich deine do/while Schleife)? Das funktioniert so nicht.
Du liest am Anfang einmal den Status für minus aus. Der ist jetzt auf HIGH.
Du kommst an der oben zitierten Codestelle an und man ist auch auf HIGH. Also geht er in den if block. Dann führt er so lange digitalWrite(7, HIGH) aus, wie minus auf LOW ist (minus ist aber auf HIGH). Weil du ein do/while gemacht hast, führt er die Schleife genau 1x aus, das garantiert ein do/while (das Gegenstück wäre die while/do Schleife, die gar nicht ausgeführt würde).
Danach wartet er 20ms und setzt den Ausgang dann wieder auf LOW.

Das heißt: Egal wie lange dein Taster gedrückt ist, der Ausgang ist immer für genau 20ms auf HIGH. Du könntest die Schleife einfach weglassen.
Code: [Select]

  if ((man == HIGH) && (minus == HIGH))
  {
    digitalWrite(7, HIGH);
    delay(20);
    digitalWrite(7, LOW);
  }

Das führt zum exakt selben Ergebnis.

Also berichte mal, was du denn eigentlich bezweckst, dann können wir dir helfen, das richtig zu realisieren.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jun 26, 2015, 09:19 pm
wird taste 6 aktiviert geht "man" auf high ... solange bis taste 1-5 gedrückt wird.

taste 6 triggern: led 6 leuchtet und "man" ist high. wenn jetzt taste 7 oder 8 gedrückt wird, leuchtet zusätzlich entsprechend led 7 oder 8 solange taste 7 oder 8 gedrückt. wird 1-5 gedrückt geht "man" auf low, 7 und 8 sind sind deaktiv.

also ... schaltungsaufbau im arduino und auch extern gelötet funzt genau so.

Title: Re: Tasterschaltung
Post by: TelosNox on Jun 26, 2015, 11:58 pm
Gemäß dem Code machen Taster 7 und Taster 8 nichts, wenn nicht auch Taster 6 zugleich gedrück ist.

Ebenso bleiben Led7 und Led8 nicht an, sondern sie flackern. Das sieht man vermutlich aber nicht, weil der Pin 20ms auf HIGH bleibt, dann auf LOW geht und dann der loop von vorne beginnt und du somit sofort wieder auf HIGH bist. Solange du einen trägen Verbraucher dran hast, ist sowas machbar aber korrekt ist es nicht.

Ich würde jetzt erwarten:
Ich drücke kurz auf Taster 6 (und lasse wieder los). Das Ding schaltet jetzt auf manuellen Modus und solange ich keinen anderen Taster (1-5) drücke, bleibt der manuelle Modus an. Solange der manuelle Modus drin ist, kann ich Taster 7 oder 8 drücken, um damit dann LED 7 bzw. 8 auszulösen. Die LEDs sollen so lange an bleiben, wie ich den jeweiligen Taster gedrück halte.

Entspricht das dem, wie dein Programm funktionieren soll? (ich will nicht wissen, was es aktuell macht, sondern wohin du am Ende damit willst)
Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 01, 2015, 07:11 am
Quote
Gemäß dem Code machen Taster 7 und Taster 8 nichts, wenn nicht auch Taster 6 zugleich gedrück ist.
hm ... im aufbau machen sie aber das was ich will ... ich tippe auf taster 6 , led 6 geht an. ich drücke taster 7 und led 7 leuchtet zusätzlich auf, solange gedrückt. ebenso 8 .... weil: "man" wird  HIGH wenn ich die taste 7 oder 8 drück  ... es wird ja die bedingung
Code: [Select]
if ((man == HIGH) && (minus == HIGH))
bzw.
Code: [Select]
if ((man == HIGH) && (plus == HIGH))
erfüllt ...


Quote
ch würde jetzt erwarten:
Ich drücke kurz auf Taster 6 (und lasse wieder los). Das Ding schaltet jetzt auf manuellen Modus und solange ich keinen anderen Taster (1-5) drücke, bleibt der manuelle Modus an. Solange der manuelle Modus drin ist, kann ich Taster 7 oder 8 drücken, um damit dann LED 7 bzw. 8 auszulösen. Die LEDs sollen so lange an bleiben, wie ich den jeweiligen Taster gedrück halte.

Entspricht das dem, wie dein Programm funktionieren soll?
jepp genau so. und das tuts auch ... ob die LED 7/8 "flackern" will ich noch mitm oszi anschauen.
Title: Re: Tasterschaltung
Post by: TelosNox on Jul 01, 2015, 07:37 am
Arfff.. Fehler meinerseits. Man ist nicht der Tasterzustand, sondern da liest du den LEDKanal aus. Ja, dann funktionierts so, aber deine + und - LEDs flackern halt (was du aber nicht siehst).
Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 02, 2015, 01:35 pm

ok .... denke so ists einfacher:


Code: [Select]
if ((man == HIGH) && (minus == HIGH))
  {
    digitalWrite(7, HIGH);
  }
  else
  {
    digitalWrite(7, LOW);
  }
  if ((man == HIGH) && (plus == HIGH))
  {
    digitalWrite(6, HIGH);
  }
  else
  {
    digitalWrite(6, LOW);
  }
Title: Re: Tasterschaltung
Post by: TelosNox on Jul 02, 2015, 02:11 pm
Jupp, so is besser.
Und wenn du noch redundantes HIGH bzw. LOW setzen des Pins vermeiden willst, dann speicherst du dir den Zustand in einer Variablen ab.

Code: [Select]
if (man == HIGH && minus == HIGH && !minusActive)
  {
    digitalWrite(7, HIGH);
    minusActive = true;
  }
  else if (minusActive)
  {
    digitalWrite(7, LOW);
    minusActive = false;
  }


Natürlich must du irgendwo noch minusActive als boolean deklarieren.

Das Gleiche dann analog für plus. So schaltest du den Pin immer nur dann, wenn er nicht schon in dem Zustand ist.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 02, 2015, 04:00 pm
So, nun hab ich gesehen, dass led7 und 8 was blödes machn, wenn ich minus und plus (versehentlich) gleichzeichzeitig drück. ist das der fall sollen 7 und 8 aus bleiben:

Code: [Select]
if ((man == HIGH) && (minus == HIGH) && (plus == LOW))

    /*Sonderfall: Wenn man (gesetzt durch Pin8 durch t06 getriggert)
     * zusammen mit minus (gesetzt durch Pin5) HIGH sind dann ...
     * sind plus und minus auf HIGH bleiben pin 6 und 7 LOW
     */

  {
    digitalWrite(7, HIGH); // Pin7 auf HIGH zusammen mit Pin8 = t06 ...
    delay(200); // Pin7 bleibt 200ms auf HIGH

  }
  else
  {
    digitalWrite(7, LOW); // ansonsten auf LOW belassen
  }


  if ((man == HIGH) && (plus == HIGH) && (minus == LOW)) //dito mit plus
  {
    digitalWrite(6, HIGH);
    delay(200);
  }
    else
    {
      digitalWrite(6, LOW);
    }

Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 03, 2015, 06:52 am
soo da nun alles so funktioniert wie ichs verstehe lass ich das jetzt nicht so stehen ...

ich nix kapier:


Code: [Select]

struct LedZustand   
{
  bool Led00: 1;
  bool Led01: 1;
  bool Led02: 1;
  bool Led03: 1;
  bool Led04: 1;
  bool Led05: 1;
  bool Led06: 1;
  bool Led07: 1;
};
LedZustand Leds ;

void setup() {
  pinMode(14, INPUT); // Pin 14 = A0 ist Eingang für Taster, PullDown
  pinMode(15, INPUT);
  pinMode(16, INPUT);
  pinMode(17, INPUT);
  pinMode(13, OUTPUT); // Pin13 .. als Ausgang
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  digitalWrite(13, HIGH); // Programmstart Pin 13 auf HIGH
}

void loop() {
  Leds.Led01 = digitalRead(14);
  Leds.Led02 = digitalRead(15);
  Leds.Led03 = digitalRead(16);
  Leds.Led04 = digitalRead(17);


  if (Leds.Led01 || Leds.Led02 || Leds.Led03 || Leds.Led04)  { // wenn irgend ein Button auf HIGH ist
    digitalWrite(13, Leds.Led01);
    digitalWrite(12, Leds.Led02);
    digitalWrite(11, Leds.Led03);
    digitalWrite(10, Leds.Led04);
  }
}



was macht:

struct LedZustand   <= struct?
{
  bool Led00: 1;       <=    ... : 1; ?? wie verstehe ich den doppelpunkt?

LedZustand Leds ;  <= ??

Leds.Led01 = digitalRead(14); <= ?? punkt operator sagt mir leider noch nix

 if (Leds.Led01 || Leds.Led02 || Leds.Led03 || Leds.Led04)  {
    digitalWrite(13, Leds.Led01);  <= wieder punkt operator



Title: Re: Tasterschaltung
Post by: michael_x on Jul 03, 2015, 08:09 am
Quote
wie verstehe ich den doppelpunkt
Gute Frage! (relativ ungewöhnliche Syntax))
Gibt die Anzahl Bits eines Bitfelds an. Hier besteht die ganze struct Ledzustand aus 8 Bit, die einzeln als Led00 usw. angesprochen werden können.

Code: [Select]
struct Ledzustand {bool Led00; /* ... */}; // definiert den Datentyp Ledzustand

Ledzustand leds; // definiert leds als Variable vom Typ Ledzustand

leds.Led00 = true; // setzt das struct-Element Led00 der Variable



Das ist Standard C/C++, nix Arduino-spezifisches, und es gibt jede Menge Informationen darüber, sicher auch einfacher als dies hier (http://www2.informatik.uni-halle.de/lehre/c/c_struct.html)

Zu Bitfeldern hier (http://www.c-howto.de/tutorial-strukturierte-datentypen-bitfelder.html)
Title: Re: Tasterschaltung
Post by: combie on Jul 03, 2015, 09:31 am
Ich habe hier auch noch eine Variante, allerdings mit 2 Problemen:
1. Es ist völlig ungetestet
2. Es wird die Verwirrung optimieren

Code: [Select]

#define ForEach(array,var) for(int var=0;var<(sizeof(array)/sizeof(array[0]));var++)

const byte sonderfunktion = 5; // 6te Taste im Block

byte RadioTastenBlock[] = {14,15,16,17,18,19};
byte RadioLedBlock[]    = {13,12,11,10,9,8};
byte ManTastenBlock[]   = {4,5};
byte ManLedBlock[]      = {7,6};

byte Tastenspeicher;

void initRadio()
{
  ForEach(RadioTastenBlock,i)
  {
    pinMode(RadioTastenBlock[i],INPUT); 
    pinMode(RadioLedBlock[i],OUTPUT); 
  }
  ForEach(ManTastenBlock,i)
  {
    pinMode(ManTastenBlock[i],INPUT); 
    pinMode(ManLedBlock[i],OUTPUT); 
  }
  setRadioTaste(0); // default setzen, erste Taste ist gedrückt
}

void setRadioTaste(byte taste)
{
  Tastenspeicher = taste; 
  ForEach(RadioLedBlock,i) digitalWrite(RadioLedBlock[i],i==taste); 
}


void tastenauswertung()
{
  ForEach(RadioTastenBlock,i)
    if(digitalRead(RadioTastenBlock[i]))
    {
       setRadioTaste(i);
       exit;
    };
   
  int count = 0;
  ForEach(ManLedBlock,i)
  {
    count += digitalRead(ManTastenBlock[i])?1:0;
    digitalWrite(ManLedBlock[i],(1 == count)&&(sonderfunktion == Tastenspeicher)); 
  }
}

void setup()
{
  initRadio();
}

void loop()
{
  tastenauswertung();
}


Leicht um weitere Taster erweiterbar.
Ich habe versucht auf Bitfelder und . Operatoren zu verzichten.
Auch das durchnummerieren von Tasten und LED ist mir nicht genehm gewesen.
In beiden Tastenblocks wird jeweils nur eine Taste ausgewertet. Weitere gedrückte Tasten werden ignoriert.

Der nächste Schritt wäre:
Die Datenstruktur überarbeiten und in Klassen gießen.

Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 10, 2015, 12:15 pm
hallo .... ich wieder ...

hab den versuch gestartet, den sketch auf nen attiny 2312 zu laden, die pins natürlich entsprechend umgemappt.
nun hab ich das phänomen, dass die Funktionen (=LEDs) nur solange an sind, wie getastet wird.

Hat der Attiny ne andere Interpretation?

Was überhaupt nicht zu funktionieren scheint, sind die internen pullups an den eingängen. Die Inputs sind zwar messbar HIGH, aber der sketch geht überhaupt nicht (auf dem 168er hingegen ja; selbstverständlich ist der sketch entsprechend umgeschrieben auf pullup).

grüssle -der mendel
Title: Re: Tasterschaltung
Post by: agmue on Jul 10, 2015, 01:51 pm
1. attiny 2312

2. Hat der Attiny ne andere Interpretation?

3. Was überhaupt nicht zu funktionieren scheint, sind die internen pullups an den eingängen.
Zu 1.: Du meinst 2313?

Zu 2.: Natürlich gibt es Unterschiede, für den Sketch in #45 sollten die aber nicht relevant sein.

Zu 3.: Bei ATtiny85 und 4313 funktionieren die Pullups wie beim UNO. Mach mal digitalWrite(13,digitalRead(2));, dann sollte es klar werden.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 15, 2015, 07:56 am
äääh ja latürnich 2313 ...

und ja, der sketch (#45) funzt soweit. muss beim umschreiben auf 2313 ein fehler eingkopiert haben.

beim 2313 funktioniert

Code: [Select]
pinMode (i1, INPUT); // Definition Eingaenge
  digitalWrite (i1, HIGH); // ... als Pullup


und

Code: [Select]
pinMode (i1, INPUT_PULLUP); // Definition Eingaenge als Pullup
   pinMode (i2, INPUT_PULLUP);


definitiv nicht. messe am input tatsächlich HIGH und seh auch, dass der input-pin bei tastendruck auf LOW gezogen wird. aber reaktion= null.



Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 15, 2015, 10:07 am
okokok ... ich revidiere!!!

määächtig großer fehler:

habe den 2313 auf nem Attiny Shield gesteckt. über die isp-pins hab ich das shield der einfachheit halber mit dem diamex-avr usb-programmier-stick mit strom versorgt .... zu verlockend war es, das shield auch gleichzeitig als steckboard zum externen verschalten zu benutzen, da sämtliche pins mit reihenbuchsen versehen sind.
die pulldown-variante hat so funktioniert, nicht aber die pullup-version.

der (rendundante) sketch funktioniert mit dem 2313 -auf nem externen board, auch in der pullup-version!!

hier die pullup-version:
Code: [Select]



// Funktioniert mit 2313
// 8 Taster funktionieren!!
// PULLUP funktioniert!!


// Setup Variablen
//---------------------------------------
int t01 = HIGH; // setze die Variable mit Namen t01 und gib ihr den Wert HIGH
int t02 = HIGH; // etc
int t03 = HIGH; // Die Variablen t01 bis man stehen fuer
int t04 = HIGH; // die Funktions-Zustaende, gesetzt duch
int t05 = HIGH; // einmaligen Tastendruck
int t06 = HIGH;
int minus = HIGH;
int plus = HIGH;
int man = HIGH;
//---------------------------------------
const int f1 = 16; // Pin-Definition Ausgaenge fuer 2313
const int f2 = 15;
const int f3 = 14;
const int f4 = 13;
const int f5 = 12;
const int f6 = 11;
const int f7 = 10;
const int f8 = 9;
//---------------------------------------
const int i1 = 0; // Pin-Definition Eingaenge fuer 2313
const int i2 = 1;
const int i3 = 2;
const int i4 = 3;
const int i5 = 4;
const int i6 = 5;
const int i7 = 6;
const int i8 = 7;
//---------------------------------------


void setup() { // Einmalige Setup-Routine
  pinMode(i1, INPUT_PULLUP); // Definition Eingaenge, interne pullups
  pinMode(i2, INPUT_PULLUP);
  pinMode(i3, INPUT_PULLUP);
  pinMode(i4, INPUT_PULLUP);
  pinMode(i5, INPUT_PULLUP);
  pinMode(i6, INPUT_PULLUP);
  pinMode(i7, INPUT_PULLUP);
  pinMode(i8, INPUT_PULLUP);
  //---------------------------------------
  pinMode(f1, OUTPUT); // Definition Ausgaenge
  pinMode(f2, OUTPUT);
  pinMode(f3, OUTPUT);
  pinMode(f4, OUTPUT);
  pinMode(f5, OUTPUT);
  pinMode(f6, OUTPUT);
  pinMode(f7, OUTPUT);
  pinMode(f8, OUTPUT);
  digitalWrite(f1, HIGH); // Programmstart f1 auf HIH
}
//---------------------------------------
void loop() { // Start Endlos-Schleife
  t01 = digitalRead(i1); // setze Var. t01-plus gleich dem Eingangspegel
  t02 = digitalRead(i2); // der jeweils an den Inputs liegenden Tastern
  t03 = digitalRead(i3);
  t04 = digitalRead(i4);
  t05 = digitalRead(i5);
  t06 = digitalRead(i6);
  man = digitalRead(f6); // man wird durch Pegel von f6 logisch gesetzt,
  minus = digitalRead(i7); // minus durch Taste 7 und
  plus = digitalRead(i8); // plus durch Taste 8

//---------------------------------------

  if (t01 == LOW)  { // wenn t01 gleich LOW dann...
    digitalWrite(f1, HIGH); // setze f1 auf HIGH ...
    digitalWrite(f2, LOW); // ... und alle anderen auf LOW
    digitalWrite(f3, LOW);
    digitalWrite(f4, LOW);
    digitalWrite(f5, LOW);
    digitalWrite(f6, LOW);
  }
  else if (t02 == LOW) // ansonsten wenn t02 gleich LOW dann ...
  {
    digitalWrite(f1, LOW);
    digitalWrite(f2, HIGH); // setze f2 auf HIGH ...
    digitalWrite(f3, LOW); // ... und alle anderen auf LOW
    digitalWrite(f4, LOW);
    digitalWrite(f5, LOW);
    digitalWrite(f6, LOW);
  }
  else if (t03 == LOW)
  {
    digitalWrite(f1, LOW);
    digitalWrite(f2, LOW);
    digitalWrite(f3, HIGH); // ... usw ...
    digitalWrite(f4, LOW);
    digitalWrite(f5, LOW);
    digitalWrite(f6, LOW);
  }
  else if (t04 == LOW)
  {
    digitalWrite(f1, LOW);
    digitalWrite(f2, LOW);
    digitalWrite(f3, LOW);
    digitalWrite(f4, HIGH);
    digitalWrite(f5, LOW);
    digitalWrite(f6, LOW);
  }
  else if (t05 == LOW)
  {
    digitalWrite(f1, LOW);
    digitalWrite(f2, LOW);
    digitalWrite(f3, LOW);
    digitalWrite(f4, LOW);
    digitalWrite(f5, HIGH);
    digitalWrite(f6, LOW);
  }
  else if (t06 == LOW)
  {
    digitalWrite(f1, LOW);
    digitalWrite(f2, LOW);
    digitalWrite(f3, LOW);
    digitalWrite(f4, LOW);
    digitalWrite(f5, LOW);
    digitalWrite(f6, HIGH);
  }
//---------------------------------------

// Sonderfall Tasten 7,8 enspr. minus und plus
  if ((man == HIGH) && (minus == HIGH) && (plus == LOW))
  // wenn man (gesetzt duch f6) und minus (f7) und plus (f8) logisch ...
  {
    digitalWrite(f7, HIGH); // dann f7 auf HIGH ...
    delay(200); // und mind. 200ms bleiben
  }
  else // ansonsten, also wenn minus und plus nicht bedient werden ...
  {
    digitalWrite(f7, LOW); // ...auf LOW bleiben...
  }

  if ((man == HIGH) && (plus == HIGH) && (minus == LOW))
  {
    digitalWrite(f8, HIGH); /// gilt für f7 und f8.
    delay(200);
  }
  else
  {
    digitalWrite(f8, LOW);
  }
// werden minus (i7) und plus (i8) gleichzeitig getriggert, bleiben f7, f8 auf LOW!!
}



Der Sketch verwendet 1.382 Bytes (67%) des Programmspeicherplatzes. Das Maximum sind 2.048 Bytes.
Globale Variablen verwenden 27 Bytes (21%) des dynamischen Speichers, 101 Bytes für lokale Variablen verbleiben. Das Maximum sind 128 Bytes.

sehr verschwenderisch, werdet ihr sagen. aber der 2313 packts noch ;-)

so, nun gehts ans verinnerlichen ... und dann mal schauen, wie ich den sketch "kürze".


Title: Re: Tasterschaltung
Post by: agmue on Jul 15, 2015, 09:47 pm
In Abwandlung eines Spruchs hier aus dem Forum: Ein Programm, das Du verstehst und das tut, was Du willst, ist ein gutes Programm!

Wenn es dann sogar in einen ATtiny paßt: Glückwunsch zum Röhrenradiotastaturprogramm!
Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 16, 2015, 03:59 pm
ääh  .... war das jetzt echt sowas wie ein kleiner schulterklopfer?

danke ... *schnüff* ...
Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 22, 2015, 06:57 am
Frage:

Wie kehre ich folgende Aussage um?

Code: [Select]
if (Leds.Led01 || Leds.Led02 || Leds.Led03 || Leds.Led04)  { // wenn irgend ein Button auf HIGH ist
    digitalWrite(13, Leds.Led01);
    digitalWrite(12, Leds.Led02);
    digitalWrite(11, Leds.Led03);
    digitalWrite(10, Leds.Led04);


Ich möcht also:

wenn Leds.LED01 oder ... oder ...   LOW ist (also !=HIGH) dann:

setze pin 13 auf den umkehrwert von Leds.Led01
setze pin 12 auf den umkehrwert von Leds.Led02
usw.

hab schon gesucht, aber offensichtlich die falsche frage ...
Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 22, 2015, 07:58 am
Ok ... richtige Frage gefunden ... ein ! und gut ist ...


Nun hab ich eine Frage nach dem Warum:

Code: [Select]
//---------------------------------------
void loop() { // Start Endlos-Schleife
  t01 = digitalRead(i1); // setze Var. t01-plus gleich dem Eingangspegel
  t02 = digitalRead(i2); // der jeweils an den Inputs liegenden Tastern
  t03 = digitalRead(i3);
  t04 = digitalRead(i4);
  t05 = digitalRead(i5);
  t06 = digitalRead(i6);
 // man = digitalRead(f6); // man wird durch Pegel von f6 logisch gesetzt,
 // minus = digitalRead(i7); // minus durch Taste 7 und
 // plus = digitalRead(i8); // plus durch Taste 8

  //---------------------------------------

  if (t01 || t02 || t03 || t04 || t05 || t06 == !HIGH) {
    digitalWrite(f1, !t01);
    digitalWrite(f2, !t02);
    digitalWrite(f3, !t03);
    digitalWrite(f4, !t04);
    digitalWrite(f5, !t05);
    digitalWrite(f6, !t06);  }


Warum wird nach loslassen einer Taste txx der jeweilige fx wieder auf LOW gesetzt?
die IF bedingung wird doch nur dann erfüllt, WENN einer der txx auf LOW ist, oder? und somit wird auch NUR DANN die digitalWrite-Kette ausgeführt? geht einer auf LOW wird ensprechender pin fx auf !LOW gesetzt, geht aber wieder auf LOW sobald die Taste losgelassen wird und alle txx durch pullup wieder HIGH sind ...
Title: Re: Tasterschaltung
Post by: agmue on Jul 22, 2015, 07:59 am
Das Stichwort könnte "De Morgansche Gesetze (http://www.mathe.tu-freiberg.de/~hebisch/cafe/algebra/boolescheAlgebren.html)" lauten. Mit dem Ausrufezeichen als Negation:

!(A || B || C || D) = (!A && !B && !C && !D)

Deine textliche Formulierung sagt aber !A || !B || !C || !D

Mit OOP Leds.Led kenne ich mich nicht aus.
Title: Re: Tasterschaltung
Post by: agmue on Jul 22, 2015, 08:09 am
Zunächst: !HIGH == LOW

if (t01) {digitalWrite(f1, !t01);} Setzt f1 auf LOW, wenn der Eingang HIGH ist. Wenn der Eingang LOW ist, passiert aber nichts.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 22, 2015, 02:34 pm

????

Code: [Select]
if (!t01 || !t02 || !t03 || !t04 || !t05 || !t06) {
    digitalWrite(f1, !t01);
    digitalWrite(f2, !t02);
    digitalWrite(f3, !t03);
    digitalWrite(f4, !t04);
    digitalWrite(f5, !t05);
    digitalWrite(f6, !t06);  }


so funktionierts. jeweilige LED leuchtet bis die nächste aktiviert wird.

echt klasse. hab den sketch "geschrumpft" von 1.382 auf 1280 bytes, globale Variablen von 27 auf 19 Bytes ... und hab nicht verstanden warum es so funktioniert, anders herum nicht. nicht im sinne des erfinders.
Title: Re: Tasterschaltung
Post by: Mendel13 on Jul 22, 2015, 02:38 pm
also, was ich ehrlich nicht verstehe:

Warum lässt
Code: [Select]
if (t01 || t02 || t03 || t04 || t05 || t06 == !HIGH) {
    digitalWrite(f1, !t01);
    digitalWrite(f2, !t02);
    digitalWrite(f3, !t03);
    digitalWrite(f4, !t04);
    digitalWrite(f5, !t05);
    digitalWrite(f6, !t06);  }

die LEDs nur leuchten, solange die jeweilige Taste gedrückt wird, während
Code: [Select]
if (!t01 || !t02 || !t03 || !t04 || !t05 || !t06) {
    digitalWrite(f1, !t01);
    digitalWrite(f2, !t02);
    digitalWrite(f3, !t03);
    digitalWrite(f4, !t04);
    digitalWrite(f5, !t05);
    digitalWrite(f6, !t06);  }

die jew. LED solange leuchten lässt, bis eine andere Taste gedrückt wird (so wie ich es vorgesehen hab)?

Title: Re: Tasterschaltung
Post by: TelosNox on Jul 23, 2015, 04:37 pm
"==" geht vor "||"
In Mathe wäre das Punkt vor Strich. Dir fehlt die Klammer.

Darum ist if (t01 || t02 || t03 || t04 || t05 || t06 == !HIGH) dann wahr, wenn
t01 high ist oder t02 high ist oder t03 high ist oder t04 high ist oder t05 high ist oder t06 low ist.
Die condition ist also immer erfüllt (einer deiner Buttons ist immer high) und demnach wird immer der write durchgeführt und alles auf low gesetzt.

Im Gegenzug dazu:
if (!t01 || !t02 || !t03 || !t04 || !t05 || !t06)
ist nur dann wahr, wenn t01 low ist oder t02 low ist oder t03 low ist etc.

Mach es dir einfacher und invertiere den Wert direkt beim Auslesen. So dass die Variablen = true sind, wenn der Button gedrückt ist
Code: [Select]

t01 = !digitalRead(i1); // setze Var. t01-plus gleich dem Eingangspegel
  t02 = !digitalRead(i2); // der jeweils an den Inputs liegenden Tastern
  t03 = !digitalRead(i3);


Somit kann deine Abfrage komplett ohne die Negierung auskommen
Code: [Select]

if (t01 || t02 || t03 || t04 || t05 || t06) {
    digitalWrite(f1, t01);
    digitalWrite(f2, t02);
...


Ich denke dann ist es viel verständlicher
Title: Re: Tasterschaltung
Post by: Mendel13 on Aug 25, 2015, 06:27 am
danke ... das hilft ;-)