ich bin noch recht neu was Arduino angeht, daher bräuchte ich eure Hilfe.
Ich habe einen Impulsdrehgeber rastend den ich gerne gegen einen Arduino Nano tauschen möchte.
Zum Drehgeber: Pin A + B, er rastet nach jeder Stellung. Beim drehen werden folgende werde ausgegeben.
Drehung rechts ausgehend A=0 B=0
(A=1 B=0 - A=1 B=1),( A=0 B=1 - A=0 B=0)
Drehung links ausgehend A=0 B=0
(A=0 B=1 - A=1 B=1),( A=1 B=0, A=0 B=0)
Folgendes würde ich gern über den Arduino realisieren, (Input) D2 Taster (+), D3 Taster (-) beim Drücken des Tasters an D2, soll D4 H, D5 L - D4 H, D5 H. beim nächsten betätigen Taster D2 , D4 L, D5 H - D4 L, D4 L, D5 L usw. beim Drücken des Tasters an D3 halt umgekehrt wie Drehrichtung links. Ich weiß aber von der Programmierung her nicht wie ich es sicher funktionierend realisieren kann
Ich hoffe aus etwas Unterstützung von Euch und bedanke mich im Voraus
Gruß
Björn
Ein Array mit den Zuständen von A und B erstellen (ungeprüft!): const struct{int a,b;} AB[] = {{0,0},{0,1},{1,1},[1,0}};
Dann einen Index iAB mit den Tasten erhöhen bzw. erniedrigen und die neuen Werte aus dem Array holen.
so würde ich doch bei einem Tastendruck von 0,0 nur auf 0,1 beim nächsten druck 1,1 erreichen.oder? es muss aber immer der ablauf gegeben sein (0,1/1,1)- (0,1/0,0)
Diesen "Ablauf" mußt Du noch erklären. Mit "(0,1/1,1)- (0,1/0,0)" kann ich nichts anfangen.
Wieviele Signale kommen vom Drehgeber, und in welcher Reihenfolge beim Drehen. Wenn es mehrer Signalwechsel geben soll, dann muß der Taster eben öfters gedrückt werden.
Also der Drehregler liefert ein zeitversetztes Signal. Ausgehend von A 0,B 0 /
ist eine Signalreihenfolge Drehrichtung rechts (Pin A 1, Pin B 0 - Pin A 1 -Pin B 1) nächste Übertragung (Pin A 0, Pin B1 - Pin A 0, Pin B 0) Drehrichtung links (Pin A 0, Pin B1 - Pin A1, Pin B1)
usw. Alles innerhalt der Klammer ist eine Übertragung des Drehimpulsgebers Diese Abfolge der Signale sollten halt im Bereich von millisec übergeben werden.
Diese Frage zielt darauf: Es gibt bisher einen Encoder. Der Encoder soll durch einen Arduino-nano und Taster ersetzt werden.
Wieso nicht gleich das Gerät an das der Drehenocder angeschlossen ist so umprogrammieren das es per Taster die entsprechenden Reaktionen wie früher mit Drehencoder zeigt?
Ist das Gerät an das der Drehencoder angeschlossen nicht umprogrammierbar?
Sehen die Signalverläufe von deinem Drehencoder so aus?
Wie viele Signalwechsel willst du jetzt pro Tastendruck machen?
Soll ein Tastendruck dem Drehen von einem Rastpunkt zum nächsten entsprechen?
Es gibt die Zeitpunkte 1,2,3,4
Zum Zeitpunkt 1 wird A auf HIGH geschaltet
Zum Zeitpunkt 2 wird B auf HIGH geschaltet
Zum Zeitpunkt 3 wird A auf LOW geschaltet
Zum Zeitpunkt 4 wird B auf LOW geschaltet
dazu durchläufst du eine Schleife mit den entsprechenden Zeitverzögerungen
Dabei ist jetzt die Frage wie viel Signalwechsel sollen da pro Tastendruck erfolgen?
ein Tastendruck zwei Signalwechsel 1,2 (3,4)
ein Tastendruck vier Signalwechsel 1,2,3,4
erstmal warum ich etwas Umbauen möchte, Ich habe einen Wohnwagen, Eine Bedieneinheit für die Heizung (die, die ich jetzt am umbauen bin) eine Bedieneinheit an einer anderen Stelle, wo ich die Umluft Ein/Ausschalten sowie Lüfterdrehzahl ändern kann, Dann wieder eine Bedieneinheit, indem ich einstellen kann wo warme Luft einströmen soll (nur Schlafbereich, WoWa allgemein, Vorzelt. (Das alles ist für mich Heizanlage. Dann noch eine Bedieneinheit für die Solaranlage, Wasser, Abwasser Anzeige, Wechselrichter hat auch noch eine Bedieneinheit USW.... Scheinbar hatte der Hersteller zu viele von den Bedienelementen und hat überall einfach mal was hin gebaut.
Ich möchte jetzt erstmal alles was mit Heizung zu tun hat auf eine Bedieneinheit bekommen.
Was soweit auch recht einfach gewesen ist dieses über einen Arduino Uno hin zu bekommen.
Das Heizung Bedienelement hat halt den Drehentcoder denn ich ersetzen möchte.
Ein Tastendruck soll zwei Signalwechsel durchführen. 1,0 1,1 ...
Leider ist die Steuerung selbst nicht Programmierbar zumindest nicht von mir
ich brauche eine Grundlage wie ich dieses umsetzen kann, da ich absolut nicht der Held bin was Arduino Programmierung angeht.
Später sollen auch die Tasten weg fallen so dass ich nachher die Steuerung über ein Touch Display vornehmen kann, das ist aber der zweite Schritt. Aufgrund des Verkabelungsaufwand soll dieses über einen Nano laufen, da dieser noch im Hauptgehäuse der Heizungssteuerung passt. dieser wird nachher über i2c an den Nano angebunden, der alle anderen Aufgaben übernommen hat.
Hallo Blörn
die Beschreibung ist gut. Jetzt wissen wir was du vorhast
Du schreibst von zwei Arduinos. Hast du jetzt schon einen Arduino programmiert ja oder nein?
I²C zum Verbinden geht nur über ganz kurze Strecken. 10 cm bis 30 cm. In einem Wohnwagen solltest du da etwas anderes nehmen. Mein Vorschlag wäre serielle Verbindung über RS485
da gibt es preiswert zu kaufende RS485-Module.
Also das mindeste was du posten kannst ist das hier
void setup() {
// put your setup code here, to run once:
}
void loop() {
// put your main code here, to run repeatedly:
}
und da könntest du dann noch ein paar Fragen als Kommentare einfügen
void setup() {
// was schreibe ich hier rein?
}
void loop() {
// was schreibe ich hier rein?
}
Das klingt so als ob du da doch schon ein paar Sachen mehr in den Sketch eintragen könntest.
Dann mach das mal oder beschreibe es so:
Ich habe die Arduino-IDE installiert bekommen
Ich konnte das "XY-Beispiel auf den Arduino flashen aber ansonsten habe ich noch keine Ahnung vom Programmieren.
Es macht am meisten Sinn den wirklichen Kenntnisstand mitzuteilen. Dann wissen die anderen auf welche Art sie Antworten müssen damit du es auch verstehst.
vgs
const byte encPosNums = 4; // Vorgabe
const bool encoderPosA[encPosNums] = {0, 1, 1, 0}; // Pin A Folge
const bool encoderPosB[encPosNums] = {0, 0, 1, 1}; // Pin B Folge
const byte pinA = 3;
const byte pinB = 4;
int8_t encPos = 0; // Aktuelle Position -> Kann auch negativ werden!
uint8_t lastEncPos = 0; // Merker letzte Position
byte umlauf = 10; // simulierte ganze Umdrehungen
const bool rechts = HIGH;
const uint32_t switchSpeed = 200; // Zeit in milliSekunden(!)
uint32_t lastMillis; // Merker letzten switch
void setup()
{
Serial.begin(115200);
Serial.println(F("Start..."));
pinMode(pinA, OUTPUT);
pinMode(pinB, OUTPUT);
Serial.println(F("Ausgabe einer Umdrehung rechts herum:"));
for (byte b = 0; b < encPosNums; b++)
{
Serial.print(F("EncoderPosition: "));
Serial.print(b);
Serial.print(' ');
Serial.print(encoderPosA[b]);
Serial.println(encoderPosB[b]);
}
}
void dreh(bool richtung) // Der simuliert die Tasten rechts / links
{
richtung == rechts ? encPos++ : encPos--;
}
void newPos() // prüft ob neue EncoderPosition und bewegt sich dort hin
{
bool ueberlauf = false;
if (lastEncPos != encPos) // Neue Position gesetzt?
{
Serial.print(F("Neue Position: "));
Serial.println(encPos);
}
if (encPos >= encPosNums || encPos < 0)
{
encPos = 0;
Serial.print(F("Berichtigte Position: "));
Serial.println(encPos);
}
digitalWrite(pinA, encoderPosA[encPos]);
digitalWrite(pinB, encoderPosB[encPos]);
lastEncPos = encPos;
}
void getPos() // Nur zur Kontrolle!
// gibt mir auf dem Seriellen Monitor den Encoderzusatnd aus
{
static bool lastPinA;
static bool lastPinB;
bool isStatePinA = digitalRead(pinA);
bool isStatePinB = digitalRead(pinB);
if (lastPinA != isStatePinA || lastPinB != isStatePinB)
{
lastPinA = isStatePinA;
lastPinB = isStatePinB;
Serial.print(F("Ausgabe auf EncoderPins: "));
Serial.print(isStatePinA);
Serial.println(isStatePinB);
}
}
void loop()
{
// Simuliert Tastendruck mit Übergabe an die Funktion dreh()
if (millis() - lastMillis >= switchSpeed)
{
lastMillis += switchSpeed;
dreh(rechts);
}
newPos(); //
getPos();
}
In der Zeile
const uint32_t switchSpeed = 200; // Zeit in milliSekunden(!)
kannst Du die Ausgabegeschwindigkeit beeinflussen
Ich hoffe es gut genug erklärtzu haben.
Was mir noch nicht klar ist, ob Du mit mit jedem Tastendruck eine Umdrehung oder einen Schritt der Umdrehung machen willst. (4 tastendrücke für eine Umdrehung)
Die Abfolge bleibt immer die selbe, das geht dann auch im ms-Bereich - ich hab da schon ein paar Variablen vorbereitet Wenn die Ausgabe mit Deiner Vorgabe stimmt und ich weiss, wie das mit den Tasten gehen soll, dann brauch ich noch die entsprechenden Pins oder ich bau das einfach blind...
Es macht am meisten Sinn den wirklichen Kenntnisstand mitzuteilen. Dann wissen die anderen auf welche Art sie Antworten müssen damit du es auch verstehst.
vgs
[/quote]
Ok ich hätte ein leeres Sektch hier einfügen können. Was habe ich bisher alles hin bekommen....
Auf dem Uno (Master) habe ich folgendes realisiert: mit folgenden Nextion 7" HMI Touch Display,
1x Motortreiber l298n, 1x Servomotor, 4x Digital Output um Optokoppler zu steuern.
über das Display Steuere ich den Motortreiber über ein PWM Signal von 100 - 250 , den Servomotor am Display über drei Buttons in drei feste Stellungen, Analog Output, mit den 4 Optokoppler steuere ich über 4 Buttons am Display diverse Funktionen. (Später sollen da auch noch Eingänge genutzt werden, wie Temperatur einlesen Füllstände auswerten etc, soweit bin ich aber noch nicht)
mein Wissensstand ist eher blutiger Anfänger, das was ich bisher gemacht habe sind eher Codeschnipsel zusammengefügt.
Warum I2c ... Ich kann das System nachher einfacher erweitern, wenn ich anfange den Laderegler der Solaranlage mit einem weiteren Arduino auszulesen und einzustellen. ich habe so die Möglichkeit gezielt einen Arduino anzusprechen. Kabellängen bis ca. einem Meter bei I2c sind eigentlich kein Problem bei einem Querschnitt von 0,5 und 2.2K Wiederständen jedenfalls habe ich noch immer schöne bzw saubere rechteckimpulse sie werden noch nicht dreieckig
Ich möchte es schon selbst bauen, sonst lerne ich es ja nicht...
es gibt so viel doku, wie ich einen Signalgeber am Arduino einlese, aber andersherum wie ich einen generiere, habe ich so leider nichts gefunden, Ist es wirklich so unüblich???
also mit jedem Tastendruck soll ein Schritt durchgeführt werden.
Auf Pin´s habe ich mich nicht festgelegt. ich würde jetzt einfach Input Taster 1 D2, Taster 2 D4, Output Pin A D7 und Pin B D8 nutzen. um mir PWM Freizuhalten.
