kleines problem mit wartezeit

International Deutsch
1

Hallo zusammen,
im Rahmen eines großen Projekts steh ich nun da und weiß wirklich nicht mehr weiter.
Alles was ich versucht habe hat wohl aufgrund Verständnissprobleme nicht richtig funktioniert.

Es geht im folgendes:

void loop {
digitalWrite(bremseA, LOW);
digitalWrite(dirA, HIGH);
analogWrite(pwmA, 255);
delay(5000);
digitalWrite(dirA, LOW);
analogWrite(pwmA, 255);
delay(5000);
}

Ich habe einen DC Motor an einem Motorshild welcher sich so links und rechts fahren lässt. Problem ist das das ganze über einen Rastschalter aktiviert wird und durch das delay das program nicht abgebrochen wird, logisch.

Ich hoffe ich habe mich verständlich ausgedrückt.
Kann mir vielleicht jemand mal meinen Code hier so umschreiben das der Motor sich nach einer festgelegten Zeit (variabel = interval) un die andere Richtung bewegt für die selbe Zeit und das ganze dann wieder von vorne los geht ?

Vielen lieben dank für eure hilfe und Aufmerksamkeit.

2

Selber machen bringt dich nur voran!

3

So groß sieh das Projekt doch gar nicht aus. :confused:

Und was da laufen soll kann man so auch nicht erkennen. Außer das das Programm 10 Sek. wartet.
Daher auch der Tipp von sschultewolter. Die delays müssen raus, sonst geht nichts.

4

Hallo,
Sorry das ich so lange gebraucht habe, ich hatte sehr viel zu tun.

Hier einmal der komplette Programmcode was ich da gebaut habe.

const int dirA = 12;          //Richtung Teller
const int dirB = 13;          //Richtung Pumpe
const int pwmA = 3;           //PWM Teller
const int pwmB = 11;          //PWM Pumpe
const int bremseA = 9;        //Bremse Teller
const int bremseB = 8;        //Bremse für Pumpe
const int pwmAVACUUM = 6;     //PWM Turbine
const int led = 22;           //LED Anschluss
const int off = 52;           //Eingang für OFF
const int on = 53;            //Eingang für ON
const int plate = 51;         //Eingang für PLATE
const int vacuum = 50;        //Eingang für VACUUM
const int pump = 24;          //Eingang für PUMP

int varOFF = 0;               //Variabel für Position OFF
int varON = 0;                //Variabel für Position ON
int varPLATE = 0;             //Variabel für Position PLATE
int varVACUUM = 0;            //Variabel für Position VACUUM
int varPUMP = 0;              //Variabel für Taster PUMP


int geschwPLATE = 255;            //Geschwindigkeit PLATE im Programm PLATE
int geschwPLATETURBINE = 188;     //Geschwindigkeit PLATE im Programm VACUUM
int geschwPUMPE = 200;            //Geschwindigkeit PUMPE
int geschwVACUUM = 100;           //Geschwindigkeit TURBINE || HÖCHTENS 200!!!! ||

void setup() {
 TCCR3B = TCCR3B & 0b11111000 | 0x01; //Frequenz kreis "A"
 TCCR2B = TCCR2B & 0b11111000 | 0x01;  //ACHTUNG TIMER ÄNDERN SICH !
 TCCR4B = TCCR4B & 0b11111000 | 0x01;
 TCCR1B = TCCR1B & 0b11111000 | 0x01;
 TCCR5B = TCCR5B & 0b11111000 | 0x01;

 pinMode(dirA, OUTPUT);             //Richtung Teller als Ausgang setzten
 pinMode(dirB, OUTPUT);             //Richtung Pumpe als Ausgang setzen
 pinMode(pwmA, OUTPUT);             //PWM Signal Teller als Ausgang setzen
 pinMode(pwmB, OUTPUT);             //PWM Signal Pumpe als Ausgang setzen
 pinMode(bremseA, OUTPUT);          //Bremse Teller als Ausgang setzen
 pinMode(bremseB, OUTPUT);          //Bremse Pumpe als Ausgang setzen
 pinMode(pwmAVACUUM, OUTPUT);       //PWM Signal Turbine als Ausgang setzen
 pinMode(led, OUTPUT);              //LED Pin als Ausgang setzen
 
 pinMode(off, INPUT);               //Rastschalter Position OFF als Eingang setzen
 pinMode(on, INPUT);                //Rastschalter Position ON als Eingang setzen
 pinMode(plate, INPUT);             //Rastschalter Position PLATE als Eingang setzen
 pinMode(vacuum, INPUT);            //Rastschalter Position VACUUM als Eingang setzen
 pinMode(pump, INPUT);              //Pumpentaster als eingang setzen

}
void pumpe(){                        //Programm Pumpe (nur aktiv wenn Programm PLATE gewählt)
 varPUMP = digitalRead(pump);       //Taster auslesen und einer variabel zuordnen
 if (varPUMP == HIGH){              //wenn Taster gedrückt
 digitalWrite(dirB,  HIGH);         //Richtung bestimmen
 digitalWrite(bremseB, LOW);        //Bremse los 
 analogWrite(pwmB, geschwPUMPE);    //Geschwindigkeit Pumpe
 }else {                            //andernfalls
   digitalWrite(bremseB, HIGH);     //Bremse an
   analogWrite(pwmB, 0);            //nicht pumpen
 }
}


void loop() {                        //Endlosschleife
varOFF = digitalRead(off);           //Schalter auslesen und einer Variabel zuordnen - Schalterstellung OFF
varON = digitalRead(on);             //Schalter auslesen und einer Variabel zuordnen - Schalterstellung ON
varPLATE = digitalRead(plate);       //Schalter auslesen und einer Variabel zuordnen - Schalterstellung PLATE
varVACUUM = digitalRead(vacuum);     //Schalter auslesen und einer Variabel zuordnen - Schalterstellung VACUUM 

if ((varOFF == HIGH) && (varON == LOW) && (varPLATE == LOW) && (varVACUUM == LOW)){             //wenn Position OFF
  digitalWrite(led, LOW);                                                                      //LED aus
  digitalWrite(bremseA, HIGH);                                                                 //Bremse Motor an

} else {                                                                                        //andernfalls
 if ((varOFF == LOW) && (varON == HIGH) && (varPLATE == LOW) && (varVACUUM == LOW)){           //wenn Position ON
   digitalWrite(led, HIGH);                                                                    //LED an 
   analogWrite(pwmA, 50);                                                                      //Motor auf pwm 50 (dient zum weichen abschalten aus position plate)
   delay(200);                                                                                 //0,2 Sekunden warten
   digitalWrite(bremseA, HIGH);                                                                //Bremse Motor an
 } 
 else {                                                                                        //andernfalls
   if ((varOFF == LOW) && (varON == LOW) && (varPLATE == HIGH) && (varVACUUM == LOW)) {        //wenn Position PLATE
     pumpe();                                                                                  //Pumpenprogramm aktiv
     digitalWrite(led, HIGH);                                                                  //LED an
     digitalWrite(bremseA, LOW);                                                               //Bremse Motor aus
     digitalWrite(dirA, HIGH);                                                                 //Richtung 
     analogWrite(pwmA, geschwPLATE);                                                           //Geschwindigkeit Motor
     analogWrite(pwmAVACUUM, 0);  //Vacuum aus (wenn man aus Programm VACUUM kommt)
     }
   else {                                                                                      //andernfalls
     if ((varOFF == LOW) && (varON == LOW) && (varPLATE == LOW) && (varVACUUM == HIGH)){       //wenn porision VACUUM 
       digitalWrite(led, HIGH);                                                                //LED an
       digitalWrite(bremseA, LOW);                                                             //Bremse los 
       digitalWrite(dirA, HIGH);                                                               //Richtung 
       analogWrite(pwmA, geschwPLATETURBINE);                                                  //Geschwindigkeit Motor
       analogWrite(pwmAVACUUM, geschwVACUUM);                                                  //Geschwindigkeit Turbine
     }
   
   }
 }
}
}

das ist Teil 1, Teil 2 folgt

5

Teil 2:

Das Gerät um welches sich hierbei Handelt ist eine art Waschmaschine.
Ein Acrylkasten in dem sich folgende "Aktoren" befinden.

  • Eine 24V DC Pumpe.
  • Ein Taster mit integrierter LED.
  • Eine 24V DC Gleichstrom Turbine.
  • Einen 24V DC Getriebemotor.
  • Einen 24V Lüfter der aber an die gleichen Klemmen wie der Gleichstrommotor angeschlossen ist der ist sozusagen außer acht zu lassen.
  • Einen Rastschalter (13 Stufen wovon ich nur 4 Stk. benötige).

Auf dem Arduino befinden sich folgende Shields (mit Pinbelegung):

  • Arduino Compatible Mega Motor Shield 13A, 5-28V - RobotShop für die Turbine (ist an PWMA und PWMB angeschlossen, der enable jumper ist auf 5V gesteckt ). Angesteuert wird das Ganze über PWMA(im sketch PWMAVACUUM genannt) an Pin 6.
    24V gehen auf die Platine über den BAT anschluss.

  • Arduino Motor Shield Rev3 | EXP Tech Hier sind die an den Anschlüssen am Kanal A (PWM A (Pin 3), DirA (Pin 12), BreakA(Pin 9)) der Motor. Am Kanal B (PwmB (Pin 11), DirB (Pin 13), BreakB (Pin8)) ist die Pumpe angeschlossen. 12V gehen auf diese Platine (habe einen Wandler an das 24V Netzteil gemacht).

  • Die Led befindet sich auf Pin 22.

  • Als nächstes habe ich einen Rastschalter (Position 1 (OFF), Position 2 (ON), Position 3 (PLATE), Position 4 (VACUUM) so angeschlossen wie hier zu sehen : Digitaler Input - Schalter auslesen « Physical Computing

  • Der Pumpentaster ist genau so angeschlossen.

Nachdem ich den Eingängen die entsprechenden Variabeln zugeordnet habe und im Setup alles als Input und Output deklariert habe sowie aufgrund komischer Geräusche vom Motor ( Ist ein altes dingen welches ich nach dem Test austauschen möchte ) die Frequenzen geändert habe, hab ich im endeffekt nur ein paar if - else abfragen in den loop gestellt um rauszufinden ob das so funktioniert.

Das tut es, irgendwas sagt mir zwar das es total unelegant ist aber in erster linie wollte ich mal endlich ein kleines erfolgserlebnis haben.

Genau da stehe ich jetzt.

Folgendes soll das Gerät können oder sagen wir mal ein Ablaufplan den ich mir ausgedacht habe.

Raste auf position (1) OFF:
-Das Gerät befindet sich im Ruhemodus, alles aus.

Raste auf position (2) ON:
-Die LED soll an gehen, weiter nichts.

Raste auf position (3) PLATE:
-Die LED soll an gehen.

-Der Motor soll mit einer festgelegten Geschwindigkeit nach links rum starten und nach 60 Sekunden (5 umdrehungen - kann man ja mit PWM sowie Zeit verändern anpassen) sanft die Drehrichtung wechseln ( mache ich es mit einem Delay geht das, aber der hält ja das program an und es ist wichtig das ich jederzeit auf ein anderes Programm wechseln kann bzw. Unterbrechen).

-Die Pumpe soll mit einem Druck auf den Pumpentaster ihren Dienst verrichten (nur so lange der Taster gedrückt ist)

Raste auf position (4) VACUUM:
-Die LED soll an gehen.

-Der Motor soll mit einer festgelegten (langsameren Geschwindigkeit als im Programm PLATE) nach links rum starten und nach 1 1/2 Umdrehungen (c.a. 15-20 Sekunden) die Drehrichtung wechseln.

-Das i Tüpfelchen wäre, dass sich die Drehrichtung nicht nur automatisch sondern zusätzlich noch manuell mit einem druck auf den Pumpentaster wechseln ließ (aber nur im VACUUM).

Wichtig dabei ist das sich jedes Programm am beliebigen Punkt abschalten lässt.

Ich hoffe ihr habt das was ich gerne realisieren möchte verstanden.
Mit der BlinkWithout Delay funktion komme ich irgendwie überhaupt nicht zurecht, der möchte dann immer links und rechts gleichzeitig drehen ich weiß nicht wie ich dem das richtig sage.

Vielen dank für eure Aufmerksamkeit und Hilfe

Lieben Gruß

P.s. Sorry noch vergessen das ganze wird mit einem Arduino Mega 2560 betrieben.

6

Der Rastenschalter ist doch vermutlich ein Drehschalter?
Und jeder Schaltzustand kommt, so wie ich es versteh, nur einmalig und allein vor. Ich meine damit, eine Variable bekommt ein High und die anderen ein Low, richtig?

Wenn das so ist, dann kannst du dir das sparen:

if ((varOFF == HIGH) && (varON == LOW) && (varPLATE == LOW) && (varVACUUM == LOW))

und nur auf "if (varOFF == HIGH){" usw. abfragen.

Weil ja alle übrigen immer auf Low stehen.

Und bitte setze deinen Code in die Code-Tags, das wird übersichtlicher.

7

Hallo,

setze den Code bitte in Code Tags ( </> Button ) oben links oder häng die .ino Datei ran.

Beschäftige Dich mit millis damit Du das delay raus bekommst. Nimm einen Taster oder Deinen Rastschalter und 2 LEDs. Jeweils eine blinkt immer vor sich hin und auf Tastendruck wechselt das blinken auf die andere LED. Wenn den Ablauf verinnerlicht hast, ist Dein Anfangsproblem ein Kinderspiel.

Oder erstmal noch einfacher ohne Taster. Programmiere nur eine blinkende LED ohne delay nur mit millis.

8

du hast die Timer 1 bis 5 geändert, meines wissens hat der Mega nur die Timer 0 bis 4. Den Teimer 0 solltest du nach Möglichkeit nicht ändern. An welchen Pins brauchst du eine höher Frequenz?

9

Timer5 gibt es auch. Sonst würde es gar nicht kompilieren.

10

du hast PWM auf 3, 11 und 6, wenn du 2, 3 und 5 nimmst, brauchst du nur Timer 3 ändern.

11

Digitaler Input - Schalter auslesen « Physical Computing

wenn du deinen Rastschalter so angeschlossen hast kann dein code nicht funktionieren, da in dem Beispiel Pullups verwendet werden, du fragst in deinem code aber auf high ab. Wenn du Pullups verwenden möchtest, brauchst du keine realen Widerstände, sondern du kannst die internen Pullups verwenden [pinMode(pin, INPUT_PULLUP); du mußt aber in deinem code auf low abfragen, oder du verwendest externePulldowns

12

Hallo und danke für die Antworten.

Ich habe den code mal eingebunden.

Jetzt habe ich mich den gesammten vormittag damit beschäftigt und mehr als einen wechsel bekomme ich nicht hin weil ich einfach zu doof bin das zu verstehen.
Ich denke das problem liegt dadrin das ich nicht wieder an den Anfang von meinem Programm komme da die Zeit ja immer weiter hoch Zählt.

Aktuell sieht der Teil vom code den ich mir da gebaut habe so aus.

void hinher2(){
  time = millis();
  sekunden = (time - startTime)/1000;
 if (sekunden < intervall){

    digitalWrite(led, HIGH);
    digitalWrite(dirA, links);
    digitalWrite(bremseA, LOW);
    analogWrite(pwmA, 255);
  }
    if (sekunden > intervall){
    digitalWrite(led, HIGH);
    digitalWrite(dirA, rechts);
    digitalWrite(bremseA, LOW);
    analogWrite(pwmA, 185); 
  }
}

Hat vielleicht noch jemand einen Rat schlag für mich was ich machen kann ?

Vielen Dank und einen schönen Tag

13 
void hinher2(){
  time = millis();
 // sekunden = (time - startTime)/1000;
 if (time - (startTime /1000) > (intervall * 2)){
    hinher2();
    }
 if (time - (startTime /1000) < intervall){
    digitalWrite(led, HIGH);
    digitalWrite(dirA, links);
    digitalWrite(bremseA, LOW);
    analogWrite(pwmA, 255);
  }else{
    digitalWrite(led, HIGH);
    digitalWrite(dirA, rechts);
    digitalWrite(bremseA, LOW);
    analogWrite(pwmA, 255); 
    }
}

So wie ich den jetzt habe funktioniert es komischerweise, auch wenn ich es nicht 100% verstehe. Ich habe einfach rumgespielt und nachdem ich die 2. If abfrage weg gemacht habe und dafür oben die Abfrage mit dem doppelten Intervall gemacht habe wechselt er.

Problem dabei ist halt das ich die Arduino uhr benutze. Ich würde am liebsten einen eigenen Timer in dem Void entwerfen damit das Gerät jedesmal exakt die gleiche routine fährt und nicht irgendwann die Drehrichtung wechselt.

Jetzt habe ich allerdings ein anderes Problem.
Bin ich im Programm (4) VACUUM und gehe zurück auf das Programm (3) PLATE bleibt die turbine an. Wie kann ich das denn jetzt abändern ?

14

schreibe die Zeile analogWrite(pwmAVACUUM, 0);  //Vacuum aus (wenn man aus Programm VACUUM kommt) direkt hinter den Funktionsaufruf pumpe()

15

ardubu:
schreibe die Zeile analogWrite(pwmAVACUUM, 0);  //Vacuum aus (wenn man aus Programm VACUUM kommt) direkt hinter den Funktionsaufruf pumpe()

Hi,

super vielen dank das hat schonmal super geklappt. War zwischenzeitlich auch auf die idee gekommen aber weiter unten wirkt das nicht so ganz.

16

ich denke mal du hast dich inzwischen ein wenig mit blink without delay auseinander gesetzt.
ich habe mal ein wenig in deinem Programm rumgefuscht, probier es mal aus.

const int dirA = 12;          //Richtung Teller
const int dirB = 13;          //Richtung Pumpe
const int pwmA = 3;           //PWM Teller
const int pwmB = 11;          //PWM Pumpe
const int bremseA = 9;        //Bremse Teller
const int bremseB = 8;        //Bremse für Pumpe
const int pwmAVACUUM = 6;     //PWM Turbine
const int led = 22;           //LED Anschluss
const int off = 52;           //Eingang für OFF
const int on = 53;            //Eingang für ON
const int plate = 51;         //Eingang für PLATE
const int vacuum = 50;        //Eingang für VACUUM
const int pump = 24;          //Eingang für PUMP

boolean varOFF = 0;               //Variabel für Position OFF
boolean varON = 0;                //Variabel für Position ON
boolean varPLATE = 0;             //Variabel für Position PLATE
boolean varVACUUM = 0;            //Variabel für Position VACUUM
boolean varPUMP = 0;              //Variabel für Taster PUMP

byte geschwPLATE = 255;            //Geschwindigkeit PLATE im Programm PLATE
byte geschwPLATETURBINE = 188;     //Geschwindigkeit PLATE im Programm VACUUM
byte geschwPUMPE = 200;            //Geschwindigkeit PUMPE
byte geschwVACUUM = 100;           //Geschwindigkeit TURBINE || HÖCHTENS 200!!!! ||

void setup() {
  TCCR1B = TCCR1B & 0b11111000 | 0x01; //Frequenz an den Pin 11 und 12 auf 31,3 kHz setzen
  TCCR3B = TCCR3B & 0b11111000 | 0x01; //Frequenz an den Pin 2, 3 und 5 auf 31,3 kHz setzen
  TCCR4B = TCCR4B & 0b11111000 | 0x01; //Frequenz an den Pin 6, 7 und 8 auf 31,3 kHz setzen
  
  pinMode(dirA, OUTPUT);             //Richtung Teller als Ausgang setzten
  pinMode(dirB, OUTPUT);             //Richtung Pumpe als Ausgang setzen
  pinMode(pwmA, OUTPUT);             //PWM Signal Teller als Ausgang setzen
  pinMode(pwmB, OUTPUT);             //PWM Signal Pumpe als Ausgang setzen
  pinMode(bremseA, OUTPUT);          //Bremse Teller als Ausgang setzen
  pinMode(bremseB, OUTPUT);          //Bremse Pumpe als Ausgang setzen
  pinMode(pwmAVACUUM, OUTPUT);       //PWM Signal Turbine als Ausgang setzen
  pinMode(led, OUTPUT);              //LED Pin als Ausgang setzen
 
  pinMode(off, INPUT);               //Rastschalter Position OFF als Eingang setzen
  pinMode(on, INPUT);                //Rastschalter Position ON als Eingang setzen
  pinMode(plate, INPUT);             //Rastschalter Position PLATE als Eingang setzen
  pinMode(vacuum, INPUT);            //Rastschalter Position VACUUM als Eingang setzen
  pinMode(pump, INPUT);              //Pumpentaster als eingang setzen

}
void pumpe(){                        //Programm Pumpe (nur aktiv wenn Programm PLATE gewählt)
  varPUMP = digitalRead(pump);       //Taster auslesen und einer variabel zuordnen
  if (varPUMP == HIGH){              //wenn Taster gedrückt
  digitalWrite(dirB,  HIGH);         //Richtung bestimmen
  digitalWrite(bremseB, LOW);        //Bremse los
  analogWrite(pwmB, geschwPUMPE);    //Geschwindigkeit Pumpe
  }else {                            //andernfalls
    digitalWrite(bremseB, HIGH);     //Bremse an
    analogWrite(pwmB, 0);            //nicht pumpen
  }
}
void linkslauf()
     {
      digitalWrite(led, HIGH);                                                                  //LED an
      digitalWrite(bremseA, LOW);                                                               //Bremse Motor aus
      digitalWrite(dirA, HIGH);                                                                 //Richtung
      analogWrite(pwmA, geschwPLATE); 
      }
void rechtslauf()
     {
      digitalWrite(led, HIGH);                                                                  //LED an
      digitalWrite(bremseA, LOW);                                                               //Bremse Motor aus
      digitalWrite(dirA, LOW);                                                                 //Richtung
      analogWrite(pwmA, geschwPLATE);  
      }

void loop() {                        //Endlosschleife
varOFF = digitalRead(off);           //Schalter auslesen und einer Variabel zuordnen - Schalterstellung OFF
varON = digitalRead(on);             //Schalter auslesen und einer Variabel zuordnen - Schalterstellung ON
varPLATE = digitalRead(plate);       //Schalter auslesen und einer Variabel zuordnen - Schalterstellung PLATE
varVACUUM = digitalRead(vacuum);     //Schalter auslesen und einer Variabel zuordnen - Schalterstellung VACUUM

if (varOFF ){             //wenn Position OFF
   digitalWrite(led, LOW);                                                                      //LED aus
   digitalWrite(bremseA, HIGH);                                                                 //Bremse Motor an
}                                                                                      //andernfalls
  if (varON ) {           //wenn Position ON
    static unsigned millis_alt;
    static boolean state;
    if (!state) {millis_alt = millis();state = HIGH;}
    digitalWrite(led, HIGH);                                                                    //LED an
    analogWrite(pwmA, 50);                                                                      //Motor auf pwm 50 (dient zum weichen abschalten aus position plate)
    if (millis() - millis_alt > 200)                                                                            //0,2 Sekunden warten
       {digitalWrite(bremseA, HIGH);state = LOW;}                                                                //Bremse Motor an
  }
                                                                                        //andernfalls
    if (varPLATE ) {        //wenn Position PLATE
      pumpe();                                                                                  //Pumpenprogramm aktiv
      analogWrite(pwmAVACUUM, 0);                                                               //Vacuum aus (wenn man aus Programm VACUUM kommt)
      static boolean state;
      int links =5000; //zeit für linkslauf
      int rechts = 5000; //zeit für rechtslauf
      unsigned long wechselPhase=millis()%(links+rechts);
      if (wechselPhase<rechts) {linkslauf();state=LOW;}
      else {rechtslauf();state=HIGH;}                                                        //Geschwindigkeit Motor
       }
                                                                                         //andernfalls
      if (varVACUUM ){       //wenn Position VACUUM
        digitalWrite(led, HIGH);                                                                //LED an
        digitalWrite(bremseA, LOW);                                                             //Bremse los
        digitalWrite(dirA, HIGH);                                                               //Richtung
        analogWrite(pwmA, geschwPLATETURBINE);                                                  //Geschwindigkeit Motor
        analogWrite(pwmAVACUUM, geschwVACUUM);                                                  //Geschwindigkeit Turbine
      }
   
    }

Du solltest dir noch Gedanken zu den Pullup- bzw. Pulldown Widerständen machen und ob du deine Schalter / Taster entprellen mußt:

17

Guten morgen.

Der Sketch funktioniert super und ist zudem noch eine ganze Ecke übersichtlicher als meiner im unteren Teil!
Vielen tausend dank dafür, solltest du mal im Kölner Raum sein sag bescheid ich geb ein aus.

Ein kleines Problem hat der Sketch nur noch wenn ich das richtig gesehen habe.

Und zwar ist der erste Wechsel immer ein wenig früher. Ich denke das liegt daran das die Zeit ja auch im Modus OFF oder ON schon gezählt wird, also stelle ich mir einen wechselinterval von 30 sekunden ein und lasse das gerät 15 sekunden im standby wechselt der motor die richtung nach 15 sekunden (somit komme ich nicht auf 5 volle umdrehungen sondern nur auf 2,5 Umdrehungen). Gibt es da eine Abhilfe gegen ?

Lasse ich meine Turbine laufen habe ich das Problem das diese nach kürzester Zeit aus geht.
Zur erinnerung, es handelt sich um folgendes shield an dem die Turbine alleine hängt (Arduino Compatible Mega Motor Shield 13A, 5-28V - RobotShop). Die Turbine hatte in vorherigen Tests nie mehr als 10 A Stromaufnahme und wenn sie angelaufen ist dann ist doch das schlimmste geschafft oder nicht? Die beiden Bausteine mit der Aufschrift ( BTN79608, viereckig für jeden PWM Ausgang einen) sind auch ziemlich warm, denke das die automatisch zum selbstschutz abschalten.

Was hat man für alternativen eine Staubsaugerturbine auf einfache Art zu betreiben? Am besten über so ein shield welches ich auf den arduino stecke.

Nochmal vielen vielen tausend dank! Sobald mein Projekt fertig ist werde ich mal ein paar Bilder hochladen damit ihr auch sehen könnt was ich mir gebastelt habe.

Lieben Gruß

18

Was hat man für alternativen eine Staubsaugerturbine auf einfache Art zu betreiben? Am besten über so ein shield welches ich auf den arduino stecke.

ich vermute mal das deine Turbine nur in eine Richtung läuft, dann brauchst du keine H-Brücke, sondern du kannst sie über einen Fet ansteuern. Bei 10A wäre der IRLZ44N brauchbar.

Was für ein Motor ist in der Turbine?

19

ardubu:
ich vermute mal das deine Turbine nur in eine Richtung läuft, dann brauchst du keine H-Brücke, sondern du kannst sie über einen Fet ansteuern. Bei 10A wäre der IRLZ44N brauchbar.

Was für ein Motor ist in der Turbine?

gibt es sowas nicht als ein fertiges Shield oder wie kann ich mir das vorstellen?

Auf der Turbine steht I.CI.180 24V DC Hz also ein gleichstrommotor der egal wie gepolt in eine Richtung läuft.

20

gibt es sowas nicht als ein fertiges Shield oder wie kann ich mir das vorstellen?

dc_Motor.pdf (18.1 KB)