Kontrolle Funktion für Motor

**Ferdinand** · 15.08.2018, 19:32

Hallo ich finde dehn Fehler nicht, ich versuche mit einer Drehzahlregelung eine Sicherheitsfunktion einzurichten das der Motor nach dem Einschalten erst los läuft wen das Poti gleich oder unter 3% ist

Code:

/*
  Analog Input

 
*/
#define MOTOR_1  2
#define MOTOR_2  4
#define POTI     A0
#define PWM      9
#define TASTER   7

#define LED      3


//int poti = A0;    // select the input pin for the potentiometer

int poti_Value = 0;  // variable to store the value coming from the sensor

int poti_prozent = 0;
bool sicherheit = false;

void setup() {
  // declare the ledPin as an OUTPUT:
  //pinMode(ledPin, OUTPUT);

 Serial.begin(9600);


  //pinMode(MOTOR_1,OUTPUT);
  //pinMode(MOTOR_2,OUTPUT);
  
  
  pinMode(LED,OUTPUT);
  
  pinMode(TASTER,INPUT_PULLUP);

  pinMode(MOTOR_1,OUTPUT);
  pinMode(MOTOR_2,OUTPUT);
  
  pinMode(PWM,OUTPUT);

  
  digitalWrite(LED, LOW); 
}


void loop() {
  
int pwmSpeed;

  // Poti Regelbereich 
  poti_Value = analogRead(POTI);
  poti_prozent = map(poti_Value, 0,1023, 0,100);
  // Ausgabe
  Serial.print("Poti = ");
  Serial.print(poti_prozent);
  Serial.println("% ");

   // Sicherheitsschaltung Poti auf 0 und Motor Aus

      
      while( sicherheit = false )
      {  
  
          if (poti_prozent <= 3 )

          {

            sicherheit = true;
            digitalWrite(LED, LOW);
          }
          else
          {
            
           digitalWrite(MOTOR_1, HIGH);
           digitalWrite(MOTOR_2, HIGH);
           
           digitalWrite(LED, HIGH);
          
          }

 
      }




  digitalWrite(MOTOR_1, HIGH);
  digitalWrite(MOTOR_2, HIGH);
  
   // Geschwindigkeit regeln
  analogWrite(PWM, poti_Value / 4);

  // Drehrichtung Links 
  digitalWrite(MOTOR_1, HIGH);
  digitalWrite(MOTOR_2, LOW);
  

  // Drehrichtung Rechts

  digitalWrite(MOTOR_1, LOW);
  digitalWrite(MOTOR_2, HIGH);


  // ENDE  
}

**Siro** · 15.08.2018, 20:06

Hallo Ferdinand

while( sicherheit = false )

heisst das nicht ==

in "C" ??

in deinem Code setzt du sicherheit auf FALSE und fragst dann nach ob es TRUE ist....(zumindest wird der Compiler das so umsetzen)
eventuell schmeisst Dir der Compiler sogar den gesamten Code der While Schleife raus, weil er ihn für unnötig hält.

Noch etwas ist mir aufgefallen:

wenn er dann tatsächlich mal in deine Schleife kommt,
dann wird der Wert des Potis aber nie wieder neu gelesen.

dein Code
poti_Value = analogRead(POTI);
poti_prozent = map(poti_Value, 0,1023, 0,100);

muss irgendwie mit in deine Schleife. Sonst kommt er aus der while Schleife auch nie wieder raus.

**Moppi** · 15.08.2018, 20:58

Hallo Ferdinand,

zur Ergänzung ein Vorschlag:

In die WHILE-Schleife muss mit ziemlicher Sicherheit ein yield() rein und natürlich die Poti-Abfrage. Denn die WHILE-Schleife kann nur beendet werden, wenn das Poti abgefragt (also der Wert gelesen und umgewandelt wird). Außerdem wird solange gewartet, bis das Poti einen bestimmten Wert unterschreitet und das kann dauern. Deshalb soll das yield() dort rein - zum Beispiel am Anfang der WHILE-Schleife.

**Ferdinand** · 16.08.2018, 01:18

was ist den ein yield()

in dieser Schleife soll nur der poti beim Start abgefragt werden sobald das poti aufgedreht wird darf der Motor nicht laufen und ich mus es erst runter drehen und das progam neu Starten (neu einschalten) wen disse Bedingung erfüllt wird kommt das eigentliche progam

hir nochmal mein aktuelles program

Code:

/*
  Analog Input

 
*/
#define MOTOR_1  2
#define MOTOR_2  4
#define POTI     A0
#define PWM      9
#define TASTER   7

#define LED      3


//int poti = A0;    // select the input pin for the potentiometer

int poti_Value = 0;  // variable to store the value coming from the sensor

int poti_prozent = 0;
bool sicherheit = 1;

void setup() {
  // declare the ledPin as an OUTPUT:
  //pinMode(ledPin, OUTPUT);

 Serial.begin(9600);


  //pinMode(MOTOR_1,OUTPUT);
  //pinMode(MOTOR_2,OUTPUT);
  
  
  pinMode(LED,OUTPUT);
  
  pinMode(TASTER,INPUT_PULLUP);

  pinMode(MOTOR_1,OUTPUT);
  pinMode(MOTOR_2,OUTPUT);
  
  pinMode(PWM,OUTPUT);

  
  digitalWrite(LED, LOW); 
}


void loop() {
  
int pwmSpeed;

  // Poti Regelbereich 
  poti_Value = analogRead(POTI);
  poti_prozent = map(poti_Value, 0,1023, 0,100);
  // Ausgabe
  Serial.print("Poti = ");
  Serial.print(poti_prozent);
  Serial.println("% ");

   // Sicherheitsschaltung Poti auf 0 und Motor Aus

      
      while( sicherheit == 0 )
      { 
         
          if (poti_prozent <= 3 )

          {

           
            digitalWrite(LED, LOW);
            
            return 0;
            
          }
          else
          {
            
           digitalWrite(MOTOR_1, HIGH);
           digitalWrite(MOTOR_2, HIGH);
           
           digitalWrite(LED, HIGH);
           return 1;
          }

 
      }




  digitalWrite(MOTOR_1, HIGH);
  digitalWrite(MOTOR_2, HIGH);
  
   // Geschwindigkeit regeln
  analogWrite(PWM, poti_Value / 4);

  // Drehrichtung Links 
  digitalWrite(MOTOR_1, HIGH);
  digitalWrite(MOTOR_2, LOW);
  

  // Drehrichtung Rechts

  digitalWrite(MOTOR_1, LOW);
  digitalWrite(MOTOR_2, HIGH);


  // ENDE  
}

**Moppi** · 16.08.2018, 08:24

Zur Unterbrechung Deiner Programmschleife, falls die längere Zeit in Anspruch nimmt. Andernfalls könnte Dir das Gerät einfrieren/abstürzen. Normal baut man das beispielhaft am Ende innerhalb loop() ein. Unterbricht die aktuelle Schleife um dem Prozessor Zeit für andere Aufgaben zu geben.

yield()

Description

Passes control to other tasks when called. Ideally yield() should be used in functions that will take awhile to complete.

Syntax

yield();

Parameters

none

Returns

nothing

- - - Aktualisiert - - -

Du initialisierst sicherheit mit 1:

Code:

bool sicherheit = 1;

In loop() geht es dann mit while weiter, while wird solange ausgeführt, wie die angegebene Bedingung erfüllt ist:

Code:

while( sicherheit == 0 )

Da sicherheit schon den Wert 1 hat, macht die while-Schleife gar nichts (While ist zur Schleifenbildung gedacht). Daher geht es dann mit dem Code weiter:

Code:

  digitalWrite(MOTOR_1, HIGH);
  digitalWrite(MOTOR_2, HIGH);
  
   // Geschwindigkeit regeln
  analogWrite(PWM, poti_Value / 4);

  // Drehrichtung Links 
  digitalWrite(MOTOR_1, HIGH);
  digitalWrite(MOTOR_2, LOW);
  

  // Drehrichtung Rechts

  digitalWrite(MOTOR_1, LOW);
  digitalWrite(MOTOR_2, HIGH);

Zum Verständnis muss man wissen: was soll sicherheit bewirken/bezwecken?

Um das Verständnis zu verbessern, warum nicht zum Beispiel so:

Code:

/*
  Analog Input

 
*/
#define MOTOR_1  2
#define MOTOR_2  4
#define POTI     A0
#define PWM      9
#define TASTER   7

#define LED      3


//int poti = A0;    // select the input pin for the potentiometer

int poti_Value = 0;  // variable to store the value coming from the sensor

int poti_prozent = 0;
bool sicherheit = 1;

void setup() {
  // declare the ledPin as an OUTPUT:
  //pinMode(ledPin, OUTPUT);

 Serial.begin(9600);


  //pinMode(MOTOR_1,OUTPUT);
  //pinMode(MOTOR_2,OUTPUT);
  
  
  pinMode(LED,OUTPUT);
  
  pinMode(TASTER,INPUT_PULLUP);

  pinMode(MOTOR_1,OUTPUT);
  pinMode(MOTOR_2,OUTPUT);
  
  pinMode(PWM,OUTPUT);

  
  digitalWrite(LED, LOW); 
}


void loop() {
  
int pwmSpeed;

  // Poti Regelbereich 
  poti_Value = analogRead(POTI);
  poti_prozent = map(poti_Value, 0,1023, 0,100);
  // Ausgabe
  Serial.print("Poti = ");
  Serial.print(poti_prozent);
  Serial.println("% ");

     
         
  if (poti_prozent > 3 )
  {
     digitalWrite(LED, HIGH);
     digitalWrite(MOTOR_1, LOW);
     digitalWrite(MOTOR_2, LOW);
     return 0;
  }
 
  digitalWrite(MOTOR_1, HIGH);
  digitalWrite(MOTOR_2, HIGH);
  
   // Geschwindigkeit regeln
  analogWrite(PWM, poti_Value / 4);

  // Drehrichtung Links 
  digitalWrite(MOTOR_1, HIGH);
  digitalWrite(MOTOR_2, LOW);
  

  // Drehrichtung Rechts

  digitalWrite(MOTOR_1, LOW);
  digitalWrite(MOTOR_2, HIGH);


  // ENDE  
}

Sofern ich das richtig verstanden habe, könntest Du das dann auch so machen:

Code:

/*
  Analog Input

 
*/
#define MOTOR_1  2
#define MOTOR_2  4
#define POTI     A0
#define PWM      9
#define TASTER   7

#define LED      3


//int poti = A0;    // select the input pin for the potentiometer

int poti_Value = 0;  // variable to store the value coming from the sensor

int poti_prozent = 0;
bool sicherheit = 1;

void setup() {
  // declare the ledPin as an OUTPUT:
  //pinMode(ledPin, OUTPUT);

 Serial.begin(9600);


  //pinMode(MOTOR_1,OUTPUT);
  //pinMode(MOTOR_2,OUTPUT);
  
  
  pinMode(LED,OUTPUT);
  
  pinMode(TASTER,INPUT_PULLUP);

  pinMode(MOTOR_1,OUTPUT);
  pinMode(MOTOR_2,OUTPUT);
  
  pinMode(PWM,OUTPUT);

  
  digitalWrite(LED, LOW); 
}


void loop() {
  
int pwmSpeed;

  // Poti Regelbereich 
  poti_Value = analogRead(POTI);
  poti_prozent = map(poti_Value, 0,1023, 0,100);
  // Ausgabe
  Serial.print("Poti = ");
  Serial.print(poti_prozent);
  Serial.println("% ");

     
         
  if (poti_prozent > 3 )
  {
     digitalWrite(LED, HIGH);
     digitalWrite(MOTOR_1, LOW);
     digitalWrite(MOTOR_2, LOW);
  }
  else
  {
 
     digitalWrite(MOTOR_1, HIGH);
     digitalWrite(MOTOR_2, HIGH);
  
     // Geschwindigkeit regeln
    analogWrite(PWM, poti_Value / 4);

    // Drehrichtung Links 
    digitalWrite(MOTOR_1, HIGH);
    digitalWrite(MOTOR_2, LOW);
  
    // Drehrichtung Rechts

    digitalWrite(MOTOR_1, LOW);
    digitalWrite(MOTOR_2, HIGH);
  }

  // ENDE 
 yield();
}

**Ceos** · 16.08.2018, 09:03

ACHTUNG Verständnisposting, hilft nicht direkt bei der Lösung aber beim Verständnis und der weitern Programmierung.

wozu du dich mal belesen solltest ist die sog. Parallele Datenverarbeitung (Vorsicht das gibts in einfach und kompliziert, für dich reicht die einfache Variante die sich nicht mit Multithreading und Multicore beschäftigt)

Wenn du als Mensch z.B. nach einem Apfel greifst, machst du mehrere Dinge parallel, du steuerst deine Linearaktoren (Muskeln), fühlst die Bewegung und Position deines Arms mit Sensoren (Nervenenden) und trackst den Apfel und deine Hand in relation zum Apfel.

Wenn du aber nur einen Prozess zu einer Zeit verarbeiten kannst (weil einfacher single Core Controller) musst du Time Slicing betreiben, also quasi jedem Vorgang nacheinander ausführen, aber immer nur ein kleines Stück.

Dafür gibt es diverse Ansätze die sich mit festem und flexiblem Timing beschäftigen, wenn es um genaue Steuerung geht aber das Timing kannst du auch erstmal weglassen.

Du musst also deine Aufgabe in Teile unterteilen die unabhängig voneinander ablaufen udn die Ergebnisse dieser TEilaufgaben zusammenführen udn vor jeder neuen Teilaufgabe die Aufgabe an die neue Situation anpassen.

Vereinfacht gesagt, du guckst (Aufgabe 1) erst wo ist dein Arm, wo ist der Apfel und schätzt die Distanz ab. Da du deinen Arm schon lange benutzt, weist du auch ohne gucken, wieviel Kraft du in den Muskel schicken musst (Aufgabe 2) damit der Arm sich bewegt ... da gehört zwar noch der Part mit dem Fühlen dazu aber den lassen wir der einfachheit weg

Wenn du Aufgabe 1 und 2 abgeschlossen hast, fängst du wieder von vorne an, du guckst also wie weit der Arm noch bewegt werden muss und passt ggf. die Kraft der Muskeln an um den Arm zu beschleunigen oder zu bremsen(Aufgabe 2).

Udn das wiederholt sich so lange bis du den Arm in der Hand hast. (edit: oha böser typo ... das hoffe ich natürlich nicht ... ich meinte den Apfel in der Hand)

Dafür braucht es dann, damit es auch übersichtlich programmiert ist, in deiner loop nur 2 methoden die immer wieder aufgerufen werden, nämlich readPoti() und controlMotor()
in deinem Projekt speicherst du dann die ergebnisse einfach global (wie dud as mit int_poti usw. schon machst) und in deiner control motor routine triffst du dann anhand des wertes deines potis eine entscheidung die motoren zu steuern. innerhalb dieser methoden ist es natürlich verboten schleifen einzubauen die nicht eine vorhersagbare anzahl an zyklen durchlaufen, sonst kommst du aus einer aufgabe nicht raus und kannst die anderen nicht mehr ausführen ....

Stell dir das einfach vor, dass du beim Arm bewegen z.B. eine Schleife einbaust die dafür sorgt dass der Arm um eine bestimmte Distanz vorwärst bewegt wird ohne dabei zwischendurch die augen zu benutzen und der Apfel rollt nur ein Stück weg ... im schlimmsten Fall kickst du den Apfel durch den Raum oder rammelst dich an einem Hindernis das plötzlich auftaucht.
Hättest du die Aufgabe so gebaut dass immer nur einmal kurz "nachgeregelt" wird, hättest du den Apfel rtotzdem sauber aufgenommen oder wärst dem Hindernis ausgewichen ...

PS ich fühle mich gerade in mein Robotik Projekt zurückversetzt ... Asuros die gleichzeitig miteinander Kommunizieren, einer Linie folgen und parallel die Motoren steuern um durch das Klebeband Labyrinth zu fahren

edit: wenn du dich an so eine einfache strukturierung deines programmes hälst, kannst du auch später ohne viel hirnverknotung neue sachen und aufgaben einbauen

**Moppi** · 16.08.2018, 09:17

Zitat von Ceos

Wenn du aber nur einen Prozess zu einer Zeit verarbeiten kannst (weil einfacher single Core Controller) musst du Time Slicing betreiben, also quasi jedem Vorgang nacheinander ausführen, aber immer nur ein kleines Stück.

Das nennt man Multithreading.

HaWe · 16.08.2018, 09:31

die Feinheiten, ob auf Multicore (wie Raspi) oder Singlecore Prozessor (wie Aduino) braucht einen Anfänger nicht zu interessieren, den interessieren nur die passenden Libs.

Für Arduino gibt es die Scheduler Lib in 2 Versionen, eine nur dür den Due, die andere auch für andere Arduinos, und für beide gibt es etliche Beispiel-Codes..

Aber Multithreading ist schwääääre Kost, wenn man Anfänger ist, da würde ich nicht unbedingt gleich meine ersten Schrritte mit machen.

**Moppi** · 16.08.2018, 09:48

Habe gerade gelesen, dass das yield sowieso bei loop() immer aufgerufen wird, das muss am Ende nicht extra drinstehen.

**Ceos** · 16.08.2018, 09:54

@Moppi ja klar ist das auch Mutlithreading, aber wenn du Multithreading bei google eingibst, wirst du mit so viel mehrkern prozessor müll erschlagen, weswegen ich bewusst solche begriffe meide wenn ich etwas erkläre die einen zu nichts sinnvollem führen, es gibg ja darum das verständnis aufzubauen und nicht jemanden mit fachartikeln abzuschrecken

Habe gerade gelesen, dass das yield sowieso bei loop() immer aufgerufen wird, das muss am Ende nicht extra drinstehen.

Genau das ist FALSCH ... es geht darum wenn du innerhalb der loop eine undefiniert lange Schleife hast yield() aufzurufen damit die arbeiten die üblicherweise NACH dem Ende deines loop gemacht werden auch dran kommen

wie ich es beschrieben habe, wenn du deine loop mit einer großen schleife laufen lässt (den arm bewegst) ohne zwischendurch auch mal die augen zu benutzen (yield oder die loop beenden) kannst du auch nichts mehr sehen und knallst irgendwo dagegen

@HAWE

die Feinheiten, ob auf Multicore (wie Raspi) oder Singlecore Prozessor (wie Aduino) braucht einen Anfänger nicht zu interessieren, den interessieren nur die passenden Libs.

habe ich irgendwo feinheiten beschrieben?????? mach deine AUGEN AUF UND LIEß was ich geschrieben habe bevor du schon wieder anfängst meine Beiträge zu kritisieren, deine ignorante Ader regt mich immer wieder auf unterlasse das bitte!

Aber Multithreading ist schwääääre Kost, wenn man Anfänger ist,

Darum habe ich es STARK VEREINFACHT, was dir aufgefallen wäre wenn du bei deiner loop des "Kritisieren" hin und weider mal yield() machst udn auch ließt bevor du deine loop() beendest und absendest

... Ich glaube ich wechsle bald das Forum