fahrzeug mit vier motoren und vier encodern

[botty]

Hallo inka,

aus Deinem Beispiel mit den mehreren Motoren hast folgende Variablen definiert gehabt:

AF_DCMotor motor_1(1);
AF_DCMotor motor_2(2);
AF_DCMotor motor_3(3);
AF_DCMotor motor_4(4);

die Zahl n, die Du hier in motor_x(n) benutzt hast, muß in der ersten Spalte des Arrays in AF_DCMotor(n) eingetragen werden.

Probier doch bitte mal aus,wenn Du die Initialisierung von oben nimmst, ob

void loop() {
  motoren[M_VL].mot.setSpeed(130);
  motoren[M_VL].mot.run(FORWARD);

  delay(3000);

  motoren[M_VL].mot.setSpeed(0);
  motoren[M_VL].mot.run(RELEASE);

  delay(3000);
}

den linken vorderen Motor alle drei Sekunden an bzw aus schaltet.

[inka]

hallo botty,

aus Deinem Beispiel mit den mehreren Motoren hast folgende Variablen definiert gehabt:

AF_DCMotor motor_1(1);
AF_DCMotor motor_2(2);
AF_DCMotor motor_3(3);
AF_DCMotor motor_4(4);

die Zahl n, die Du hier in motor_x(n) benutzt hast, muß in der ersten Spalte des Arrays in AF_DCMotor(n) eingetragen werden.

so?

struct motor motoren[M_MAX] = 
{ 
  { AF_DCMotor(1), 4, 18, 0, 0 }, // M_VL
  { AF_DCMotor(2), 1, 19, 0, 0 }, // M_HL
  { AF_DCMotor(3), 3, 20, 0, 0 }, // M_VR
  { AF_DCMotor(4), 2, 21, 0, 0 }  // M_HR
};

Probier doch bitte mal aus,wenn Du die Initialisierung von oben nimmst, ob

void loop() {
  motoren[M_VL].mot.setSpeed(130);
  motoren[M_VL].mot.run(FORWARD);

  delay(3000);

  motoren[M_VL].mot.setSpeed(0);
  motoren[M_VL].mot.run(RELEASE);

  delay(3000);
}

den linken vorderen Motor alle drei Sekunden an bzw aus schaltet.

der - so wie ich Dich verstanden habe geänderte code sieht so aus:

#include <AFMotor.h>

/*
 * Benamte Indexe. Wichtig: Alle Schleifen basieren auf der
 * Annahme, dass M_VL das erste Element und mit 0 initialisiert
 * ist. M_MAX muss ausserdem _immer_ das letzte Element sein da
 * es die Groesse des Arrays s.u. bestimmt.
 */
enum motoren_e 
{
  M_VL = 0,   // Motor vorne links
  M_HL,
  M_VR,
  M_HR,
  M_MAX 
};

/* 
 *  Infos zu einem Motor zusammenfassen.
 */
struct motor 
{
  AF_DCMotor mot;
  uint8_t enc_pin;
  // volatile damit der Compiler keine 'dummen' Optimierung macht.
  volatile uint32_t ticks;  

  unsigned long start_time; 
  unsigned long stop_time;
};

/*
 * Hier werden die PWM Channel - Encoder Pin Paare gesetzt.
 * Restliche Elemente muessen ebenfalls initialisiert werden.
 * Werte pruefen ob sie zu den Namen oben passen.
 * Fuer die externen Interrupts sind die Pins 2,5,18-21
 * erlaubt. Hardware anpassen.
 */
struct motor motoren[M_MAX] = 
{ 
  { AF_DCMotor(1), 4, 18, 0, 0 }, // M_VL
  { AF_DCMotor(2), 1, 19, 0, 0 }, // M_HL
  { AF_DCMotor(3), 3, 20, 0, 0 }, // M_VR
  { AF_DCMotor(4), 2, 21, 0, 0 }  // M_HR
};

 // Anzahl der Encoderstriche fuer eine Umdrehung
const static double ticks_per_rev = 40;
const static double durchmesser  = 6.5; // in cm;
const static double u_per_tick   = (3.1415926535897932384626433832795 * durchmesser) / ticks_per_rev;

/*
 * Interruptroutinen mit der gleichen Namenskonvention wie
 * oben.
 */
void motor_isr_m_vl(void) { motoren[M_VL].ticks++; }
void motor_isr_m_vr(void) { motoren[M_VR].ticks++; }
void motor_isr_m_hl(void) { motoren[M_HL].ticks++; }
void motor_isr_m_hr(void) { motoren[M_HR].ticks++; }


void setup() 
{
  //Serial.begin(115200);
  Serial.begin(9600);

  for(uint8_t idx = M_VL; idx < M_MAX; idx++) 
  {
    pinMode(motoren[idx].enc_pin, INPUT_PULLUP);
//    motor_init_pos(idx);
  }

  /*
   * Hier wird die Verbindung hergestellt zwischen Pin und Interruptroutine.
   * Die Namen muessen zueinander passen.
   * Durch CHANGE werden beide Uebergaenge beruecksichtigt.
   */
  attachInterrupt(digitalPinToInterrupt(motoren[M_VL].enc_pin), motor_isr_m_vl, CHANGE);
  attachInterrupt(digitalPinToInterrupt(motoren[M_HL].enc_pin), motor_isr_m_hl, CHANGE);
  attachInterrupt(digitalPinToInterrupt(motoren[M_VR].enc_pin), motor_isr_m_vr, CHANGE);
  attachInterrupt(digitalPinToInterrupt(motoren[M_HR].enc_pin), motor_isr_m_hr, CHANGE);
}

/*
 * Alle Motoren an, bis eine Umdrehung erreicht ist. Es wird alle 
 * halbe Sekunde der Zustand der Ticks pro Motor ausgeben.
 */
 
void loop() {
  motoren[M_VL].mot.setSpeed(130);
  motoren[M_VL].mot.run(FORWARD);

  delay(3000);

  motoren[M_VL].run(RELEASE);

  delay(3000);
}

 /*
void loop() 
{
  unsigned long log_time = 0;
  unsigned long ticks_tmp = 0;
  unsigned long all_ticks_tmp[M_MAX] = { 0, 0, 0, 0 };
  String out_s = "";
  bool alle_aus = false;

  // Alle Motoren an.
  for(uint8_t idx = M_VL; idx < M_MAX; idx++) 
  {
    if( ! motor_laeuft(idx) )
      motor_start(idx, 200/2+3, FORWARD);
  }

  while( ! alle_aus ) 
  {
    // Wenn die Anzahl der Ticks fuer eine Umdrehung
    // erreicht ist - Motor aus.
    for(uint8_t idx = M_VL; idx < M_MAX; idx++) {
      if(motor_laeuft(idx) && motor_hole_ticks(idx) >= ticks_per_rev) 
      {
        motor_stop(idx);
      }
    }

    // Ticks und Strecke ausgeben
    static const int wtime = 250;
    if(log_time + wtime <= millis() ) 
    {
      out_s = "";
      out_s += millis() + ": ";

      for(uint8_t idx = M_VL; idx < M_MAX; idx++) 
      {
        out_s += idx + " ";
        out_s += motoren[idx].ticks + " ";  // Hier koennte jetzt ein Interrupt unterbrechen!
        out_s += motor_strecke_gefahren(idx);

        ticks_tmp = 0;
        motor_ticks_per_milli(idx, &ticks_tmp);
        out_s += " " + ticks_tmp;

        if(idx == M_MAX - 1)
          out_s += "\n";
        else
          out_s += ", ";
      }

      for(uint8_t idx = 0; idx < M_MAX; idx++)
        all_ticks_tmp[idx] = 0;
        
      motor_ticks_per_milli_fuer_alle(all_ticks_tmp, M_MAX);

      for(uint8_t idx; idx < M_MAX; idx++)
        out_s += all_ticks_tmp[idx] + " ";

      Serial.println(out_s);

      log_time = wtime + millis();
    }

    // pruefen ob alle Motoren aus sind.
    for(uint8_t idx = M_VL, alle_aus = true; alle_aus && idx < M_MAX; idx++) 
    {
      alle_aus = alle_aus && ( ! motor_laeuft(idx) );
    }
  }

  while(1);
  // Oder nach 2sec geht's von vorne los.
  // delay(2000);
}*/

/*
 * Faehrt den Motor auf den ersten HIGH Level des Encoderpins.
 * Falls er schon HIGH ist wird erst in ein LOW gefahren und
 * beim naechsten HIGH gestoppt.
 */
void motor_init_pos(uint8_t idx) 
{
  if(idx >= M_MAX)
    return;

  if(motor_laeuft(idx))
    motor_stop(idx);
    
  // Wenn wir bereits eine 1 haben, dann fahren wir erstmal bis zur
  // naechsten 0.
  if(digitalRead(motoren[idx].enc_pin)) 
  {
    motoren[idx].mot.setSpeed(255/3);
    motoren[idx].mot.run(FORWARD);
    
    while(digitalRead(motoren[idx].enc_pin));
  }

  // Wir sind in ner 0, wissen aber nicht ob sich der Motor schon dreht.
  if( ! digitalRead(motoren[idx].enc_pin) ) 
  {
    motoren[idx].mot.setSpeed(255/4);
    motoren[idx].mot.run(FORWARD);

    while( ! digitalRead(motoren[idx].enc_pin) );

    motoren[idx].mot.setSpeed(0);
    motoren[idx].mot.run(RELEASE);

    // Bremsen evtl. nicht noetig oder muss angepasst werden.
    /*
    delayMicroseconds(75);
    motoren[idx].mot.setSpeed(255/5);
    motoren[idx].mot.run(BACKWARD);
    delayMicroseconds(100);
    motoren[idx].mot.setSpeed(0);
    motoren[idx].mot.run(RELEASE);
    */
  }
}

/*
 * 
 */
bool motor_laeuft(uint8_t idx) 
{
  if(idx >= M_MAX)
    return false;

  return motoren[idx].start_time > 0 && motoren[idx].start_time == motoren[idx].stop_time;
}

/*
 * idx - der Motor Index
 * pwm und dir wie in AF_DCMotor.
 */
void motor_start(uint8_t idx, uint8_t pwm, uint8_t dir) 
{
  if(idx >= M_MAX)
    return;

  motor_setze_ticks(idx, 0);
  motoren[idx].start_time = motoren[idx].stop_time = millis();
  motoren[idx].mot.setSpeed(pwm);
  motoren[idx].mot.run(dir);
}

/*
 * Fuer den Fall das zwischen motor_start und motor_stop die pwm nicht 
 * geaendert wird liesse sich aus der Zeit und der Strecke s.u. grob die
 * Geschwindigkeit ermitteln (Be- und Entschleunigung vernachlaessgt).
 */
void motor_stop(uint8_t idx) 
{
  if(idx >= M_MAX)
    return;

  motoren[idx].mot.setSpeed(0);
  motoren[idx].mot.run(RELEASE);
  motoren[idx].stop_time = millis();
}

/*
 * Liesst den ticks Wert interrupt safe.
 */
inline uint32_t motor_hole_ticks(uint8_t idx) 
{ 
  if(idx >= M_MAX)
    return 0;
    
  noInterrupts();
  uint32_t tmp = motoren[idx].ticks;
  interrupts();

  return tmp;
}

/*
 * Setzt den ticks Wert interrupt safe.
 */
inline void motor_setze_ticks(uint8_t idx, uint32_t val) 
{
  if(idx >= M_MAX)
    return;
    
  noInterrupts();
  motoren[idx].ticks = val;
  interrupts();
}

/*
 * 
 */
void motor_ticks_per_milli(uint8_t idx, unsigned long *res) 
{
  if(idx >= M_MAX) 
  {
    *res = 0;
    return;  
  }
  
  *res = motor_hole_ticks(idx) / (millis() - motoren[idx].start_time);
}

/*
 * Zu _einem_ Zeitpunkt werden alle Ticks/Milli ausgerechnet.
 */
void motor_ticks_per_milli_fuer_alle(unsigned long *res, uint8_t n) 
{
  unsigned long *b = 0;
  unsigned long tstamp = 0;
  
  if(n != M_MAX)
    return;

  b = res;
  noInterrupts();
  tstamp = millis();
  while(b < res + n) 
  {
    *b = motoren[b - res].ticks;
    b++;
  }
  interrupts();

  for(b = res; b < res + n; b++) {
    *b = *b / (tstamp - motoren[b - res].start_time);
  }
}

/*
 * Rechnet die gefahrenen Zentimeter anhand der Ticks aus.
 */
double motor_strecke_gefahren(uint8_t idx) 
{
  if(idx >= M_MAX)
    return 0.0;
    
  return motor_hole_ticks(idx) * u_per_tick;
}

/*
 * Rechnet fuer alle Motoren zu _einem_ Zeitpunkt die Strecke 
 * aus.
 */
void motor_strecke_fuer_alle(double *res, int n) 
{
  if(n != M_MAX)
    return;
  
  double *b = 0;
  unsigned long tmps[M_MAX];
  uint8_t idx = 0;

  noInterrupts();
  while(idx < M_MAX) {
    tmps[idx] = motoren[idx].ticks;
    idx++;
  }
  interrupts();

  for(b = res; b < res + n; b++) 
  {
    *b = tmps[b-res] * u_per_tick;
  }
}

und lässt sich nicht kompilieren (ich sagte es schon, sehr sportlich der code für meine programmierkünste )

Arduino: 1.6.6 (Linux), Board: "Arduino Mega ADK"

/home/georg/Arduino/sainsmart_car/fahren_mit timer/botty_4_motoren_1/botty_4_motoren_1.ino: In function 'void loop()':
botty_4_motoren_1:95: error: 'struct motor' has no member named 'run'
   motoren[M_VL].run(RELEASE);
                 ^
exit status 1
'struct motor' has no member named 'run'

  Dieser Report hätte mehr Informationen mit
  "Ausführliche Ausgabe während der Kompilierung"
  aktiviert in Datei > Einstellungen.

[botty]

Sorry ich habe das nicht gut erklärt. Du hast ein Feld mehr eingeführt dadurch das du die Zahlen eingefügt hast. Die Anzahl der Zeilen der "struct motor" muß mit der Anzahl der Spalten bei der Initialisierung übereinstimmen.

#include <AFMotor.h>

/*
 * Benamte Indexe. Wichtig: Alle Schleifen basieren auf der
 * Annahme, dass M_VL das erste Element und mit 0 initialisiert
 * ist. M_MAX muss ausserdem _immer_ das letzte Element sein da
 * es die Groesse des Arrays s.u. bestimmt.
 */
enum motoren_e 
{
  M_VL = 0,   // Motor vorne links
  M_HL,
  M_VR,
  M_HR,
  M_MAX 
};

/* 
 *  Infos zu einem Motor zusammenfassen.
 */
struct motor 
{
  AF_DCMotor mot;
  uint8_t enc_pin;
  // volatile damit der Compiler keine 'dummen' Optimierung macht.
  volatile uint32_t ticks;  

  unsigned long start_time; 
  unsigned long stop_time;
};

/*
 * Hier werden die PWM Channel - Encoder Pin Paare gesetzt.
 * Restliche Elemente muessen ebenfalls initialisiert werden.
 * Werte pruefen ob sie zu den Namen oben passen.
 * Fuer die externen Interrupts sind die Pins 2,5,18-21
 * erlaubt. Hardware anpassen.
 */
struct motor motoren[M_MAX] = 
{ 
  { AF_DCMotor(4), 18, 0, 0, 0 }, // M_VL
  { AF_DCMotor(1), 19, 0, 0, 0 }, // M_HL
  { AF_DCMotor(3), 20, 0, 0, 0 }, // M_VR
  { AF_DCMotor(2), 21, 0, 0, 0 }  // M_HR
};

 // Anzahl der Encoderstriche fuer eine Umdrehung
const static double ticks_per_rev = 40;
const static double durchmesser  = 6.5; // in cm;
const static double u_per_tick   = (3.1415926535897932384626433832795 * durchmesser) / ticks_per_rev;

/*
 * Interruptroutinen mit der gleichen Namenskonvention wie
 * oben.
 */
void motor_isr_m_vl(void) { motoren[M_VL].ticks++; }
void motor_isr_m_vr(void) { motoren[M_VR].ticks++; }
void motor_isr_m_hl(void) { motoren[M_HL].ticks++; }
void motor_isr_m_hr(void) { motoren[M_HR].ticks++; }


void setup() 
{
  //Serial.begin(115200);
  Serial.begin(9600);

  for(uint8_t idx = M_VL; idx < M_MAX; idx++) 
  {
    pinMode(motoren[idx].enc_pin, INPUT_PULLUP);
//    motor_init_pos(idx);
  }

  /*
   * Hier wird die Verbindung hergestellt zwischen Pin und Interruptroutine.
   * Die Namen muessen zueinander passen.
   * Durch CHANGE werden beide Uebergaenge beruecksichtigt.
   */
  attachInterrupt(digitalPinToInterrupt(motoren[M_VL].enc_pin), motor_isr_m_vl, CHANGE);
  attachInterrupt(digitalPinToInterrupt(motoren[M_HL].enc_pin), motor_isr_m_hl, CHANGE);
  attachInterrupt(digitalPinToInterrupt(motoren[M_VR].enc_pin), motor_isr_m_vr, CHANGE);
  attachInterrupt(digitalPinToInterrupt(motoren[M_HR].enc_pin), motor_isr_m_hr, CHANGE);
}

/*
 * Alle Motoren an, bis eine Umdrehung erreicht ist. Es wird alle 
 * halbe Sekunde der Zustand der Ticks pro Motor ausgeben.
 */
 
void loop() {
   unsigned long time;

  motoren[M_VL].mot.setSpeed(130);
  motoren[M_VL].mot.run(FORWARD);

  for(time = millis(); time + 3000 >= millis(); ) {
    delay(10);
    Serial.print(motoren[M_VL].ticks);
    Serial.print(" ");
  }
  Serial.println("");

  motoren[M_VL].mot.setSpeed(0);
  motoren[M_VL].mot.run(RELEASE);

  delay(3000);
}

[inka]

super, danke, botty,

läuft und wird zum begreifen von interrupts verwendet. Aber auch das andere war nicht umsonst. Ich wäre z.b. nie auf die idee gekommen, dass man so

for(uint8_t idx = M_VL; idx < M_MAX; idx++) 
{
    pinMode(motoren[idx].enc_pin, INPUT_PULLUP);
}

quasi auf einen schlag vier motoren initialisieren kann

und so

for(uint8_t idx = M_VL; idx < M_MAX; idx++) {
    if( ! motor_laeuft(idx) )
      motor_start(idx, 255/2+3, FORWARD);

für alle 4 motoren abfragen kann, ob sie laufen und wenn nicht diese dann starten kann!

was bewirkt dieses "255/2+3" eigentlich genau??

p.s.

sorry diese WE ist bei mir volles Programm.

keinen stress mit antworten!

[botty]

Hallo inka,

"255/2+3" bedeutet das der Duty Cycle ca 51% lang ist. War in Gedanken wohl noch bei Brüchen und Prozent, da schreib ich schonmal sowas umständlich. Aber der Compiler rechnet das ja zur Übersetzungszeit aus, da kann man das mal machen.

Zu den for()-Schleifen, die sind so gedacht, so kann man z.B.

// Fuer die linke Seite
for(uint8_t idx = M_VL; idx < M_VR; idx++) {
    motor_stop(idx);
}

// Fuer die rechte Seite
for(uint8_t idx = M_VR; idx < M_MAX; idx++) {
    motor_stop(idx);
}

machen. Sprich die Indexe geben an, mit welcher Seite man arbeitet. Die Funktion/en im Schleifenrumpf beschreibt/en was passieren soll.

Falls Du Lust und die Zeit hast, wäre es gut, wenn Du nochmal in 'nem C-Buch oder Tutorial nachschlägst, was Arrays (dt. Felder) sind und wie man sie benutzt. Das gleiche gilt für Strukturen (struct) und Aufzählungstypen (enum), diese drei Dinge spielen hier mit den Funktionen zusammen.

Grüße
Chris

[Sisor]

Das Schlüsselwort struct ist hier falsch -> weglassen.

struct motor motoren[M_MAX] = 
{ 
  { AF_DCMotor(1), 4, 18, 0, 0 }, // M_VL
  { AF_DCMotor(2), 1, 19, 0, 0 }, // M_HL
  { AF_DCMotor(3), 3, 20, 0, 0 }, // M_VR
  { AF_DCMotor(4), 2, 21, 0, 0 }  // M_HR
};

[inka]

hi botty,

jetzt läuft der motor 4 (VL) für 3 sec, 3 sec bleibt er stehen, mit oder ohne "struct" - was bedeutet das in dem zusammenhang?

[Sisor]

struct erwartet normalerweise einen nachstehenden Bezeichner und keinen Datentyp (hier motor, den du vorher definiert hast). Daher wundert mich, dass der Code so kompiliert wird. Ohne 'struct' ist das eine simple Felddefinition mit direkter Initialisierung.

[botty]

Sisor,
bei allem Respekt schau nochmal genau hin:

erst wird der Datentyp "struct motor" deklariert und dann die Array-Variable "motoren" definiert und die ist vom Typ "struct motor". Die Elemente des Arrays werden dann mit den Werten initialisiert, dat is aber mal ganz sicher so korrekt. Könnte es sein das Du hier

struct motor {
/// Elemente
};

mit

typedef struct {
// Elemente
} motor;

verwechselst? Dat sind nämlich zwei Paar unterschiedliche Schuhe.


inka, in dem Zusammenhang stehen lassen, das ist vollkommen korrektest C was ich da hingeschrieben habe.

Hat Dein Programm denn jetzt was auf der Konsole ausgegeben oder kam nix? Wenn der Encoder vom Rad das sich gedreht hat, am Pin 18 liegt, hätte er eigentlich fortlaufend aufsteigende Zahlen anzeigen müssen, was ja der Sinn der ganzen Sache ist.

[Sisor]

Ist zwar Geschmackssache, aber statt struct würde ich C++Vererbung empfehlen. Beispiel:

#include <AFMotor.h>

class myMotor : public AF_DCMotor {
  public:
    uint8_t enc_pin;
    volatile uint32_t ticks = 0;  
    uint32_t start_time = 0; 
    uint32_t stop_time = 0;
    
    myMotor(uint8_t motornum, uint8_t enc_pin) : AF_DCMotor(motornum) {
      this->enc_pin = enc_pin;
    }  
};

enum motoren_e { M_VL, M_HL, M_VR, M_HR, M_MAX };
myMotor motor[4] { 
   myMotor(1,18) , // M_VL
   myMotor(2,19) , // M_HL
   myMotor(3,20) , // M_VR
   myMotor(4,21)   // M_HR
};


void setup() { 
  motor[M_VL].ticks = 55;
}

void loop() {
  motor[M_VL].setSpeed(127);
  motor[M_VL].run(FORWARD);
}