fahrzeug mit vier motoren und vier encodern

[inka]

hallo allerseits,

in den letzten wochen habe ich ein vierrädriges fahrzeug entwickelt

mit diesen getriebemotoren und encodern, verwendet wird ein arduino mega 2560 R3 und das motorshield L293D V1 von sainsmart (chinesischer clone):


der code für einen motor:

#include <AFMotor.h>

AF_DCMotor motor_1(1);

#define encoder_1 22
int wert_1;
int summe_1;
int zaehler_1;

void setup() 
{
  pinMode(encoder_1, INPUT_PULLUP);

  Serial.begin(9600);
  Serial1.begin(9600);

  wert_1=0;
  summe_1=0;
  zaehler_1=0;
}

void loop() 
{
  wert_1=digitalRead(encoder_1);

  if (summe_1 <= 19 && zaehler_1 == 0)
  {
    motor_1.setSpeed(120);
    motor_1.run(FORWARD);
    zaehler_1 = 1;
    Serial.print(wert_1);
    Serial.print("    ");
    Serial.println(summe_1);
  }

  else if (summe_1 <= 19 && zaehler_1 == 1)
  {
    zaehler_1 = 0;
    summe_1 = (summe_1 + wert_1);
    Serial.print(wert_1);
    Serial.print("    ");
    Serial.println(summe_1);
    motor_1.setSpeed(0);
    motor_1.run(RELEASE);
  }
  

}

hat auch (über den serialmonitor) durchaus brauchbare ergebnisse gebracht:

1    0 
1    1 
1    1 
1    2 
1    2 
1    3 
1    3 
1    4 
1    4 
1    5 
1    5 
1    6 
1    6 
0    6 
0    6 
0    6 
0    6 
0    6 
0    6 
0    6 
0    6 
1    7 
1    7 
0    7 
0    7 
0    7 
0    7 
1    8 
1    8 
0    8 
0    8 
0    8 
1    8 
0    8 
0    8 
0    8 
1    8 
0    8 
0    8 
0    8 
1    8 
0    8 
0    8 
1    9 
0    9 
0    9 
0    9 
1    10 
0    10 
0    10 
0    10 
0    10 
1    10 
0    10 
0    10 
1    11 
0    11 
1    12 
0    12 
0    12 
0    12 
0    12 
1    12 
0    12 
1    12 
0    12 
0    12 
0    12 
0    12 
0    12 
0    12 
1    13 
0    13 
1    14 
0    14 
1    15 
0    15 
1    16 
0    16 
1    17 
0    17 
1    18 
0    18 
1    19 
0    19 
0    19 
0    19 
0    19 
0    19 
0    19 
1    19 
0    19 
1    19 
0    19 
0    19 
0    19 
0    19 
1    20

das rad dreht sich noch nicht genau 1x um 360° beim erreichen der 20 signale vom encoder, dass wäre aber - dachte ich - beherrschbar...


die erweiterung des codes für vier motoren (im prinzip das erste beispiel vervierfacht):

#include <AFMotor.h>

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

#define encoder_1 22
#define encoder_2 52
#define encoder_3 53
#define encoder_4 23

int wert_1;
int wert_2;
int wert_3;
int wert_4;

int summe_1;
int summe_2;
int summe_3;
int summe_4;

int zaehler_1;
int zaehler_2;
int zaehler_3;
int zaehler_4;

void setup() 
{
  pinMode(encoder_1, INPUT_PULLUP);
  pinMode(encoder_2, INPUT_PULLUP);
  pinMode(encoder_3, INPUT_PULLUP);
  pinMode(encoder_4, INPUT_PULLUP);

  Serial.begin(9600);
  Serial1.begin(9600);

  wert_1=0;
  wert_2=0;
  wert_3=0;
  wert_4=0;

  summe_1;
  summe_2;
  summe_3;
  summe_4;

  zaehler_1=0;
  zaehler_2=0;
  zaehler_3=0;
  zaehler_4=0;

}

void loop() 
{
  wert_1=digitalRead(encoder_1);
  wert_2=digitalRead(encoder_2);
  wert_3=digitalRead(encoder_3);
  wert_4=digitalRead(encoder_4);
  
  
   if (summe_1 <= 9 && zaehler_1 == 0)
  {
    motor_1.setSpeed(150);
    motor_1.run(FORWARD);
    zaehler_1 = 1;
    Serial.print(wert_1);
    Serial.print("    ");
    Serial.println(summe_1);
    Serial1.print(wert_1);
    Serial1.print("    ");
    Serial1.println(summe_1);
  }

  else if (summe_1 <= 9 && zaehler_1 == 1)
  {
    zaehler_1 = 0;
    summe_1 = (summe_1 + wert_1);
    Serial.print(wert_1);
    Serial.print("    ");
    Serial.println(summe_1);
    Serial1.print(wert_1);
    Serial1.print("    ");
    Serial1.println(summe_1);
    motor_1.setSpeed(0);
    motor_1.run(RELEASE);
  }
 
    if (summe_2 <= 9 && zaehler_2 == 0)
  {
    motor_2.setSpeed(150);
    motor_2.run(FORWARD);
    zaehler_2 = 1;
    Serial.print(wert_2);
    Serial.print("        ");
    Serial.println(summe_2);
    Serial1.print(wert_2);
    Serial1.print("        ");
    Serial1.println(summe_2);
  }

  else if (summe_2 <= 9 && zaehler_2 == 1)
  {
    zaehler_2 = 0;
    summe_2 = (summe_2 + wert_2);
    Serial.print(wert_2);
    Serial.print("        ");
    Serial.println(summe_2);
    Serial1.print(wert_2);
    Serial1.print("        ");
    Serial1.println(summe_2);
    motor_2.setSpeed(0);
    motor_2.run(RELEASE);
  }
 
  if (summe_3 <= 9 && zaehler_3 == 0)
  {
    motor_3.setSpeed(150);
    motor_3.run(FORWARD);
    zaehler_3 = 1;
    Serial.print(wert_3);
    Serial.print("            ");
    Serial.println(summe_3);
    Serial1.print(wert_3);
    Serial1.print("            ");
    Serial1.println(summe_3);
  }

  else if (summe_3 <= 9 && zaehler_3 == 1)
  {
    zaehler_3 = 0;
    summe_3 = (summe_3 + wert_3);
    Serial.print(wert_3);
    Serial.print("            ");
    Serial.println(summe_3);
    Serial1.print(wert_3);
    Serial1.print("            ");
    Serial1.println(summe_3);
    motor_3.setSpeed(0);
    motor_3.run(RELEASE);
  }
  
    if (summe_4 <= 9 && zaehler_4 == 0)
  {
    motor_4.setSpeed(150);
    motor_4.run(FORWARD);
    zaehler_4 = 1;
    Serial.print(wert_4);
    Serial.print("                ");
    Serial.println(summe_4);
    Serial1.print(wert_4);
    Serial1.print("                ");
    Serial1.println(summe_4);
  }

  else if (summe_4 <= 9 && zaehler_4 == 1)
  {
    zaehler_4 = 0;
    summe_4 = (summe_4 + wert_4);
    Serial.print(wert_4);
    Serial.print("                ");
    Serial.println(summe_4);
    Serial1.print(wert_4);
    Serial1.print("                ");
    Serial1.println(summe_4);
    motor_4.setSpeed(0);
    motor_4.run(RELEASE);
  }
 
}

brachte aber ergebnisse, die so nicht bleiben können:

0    0 
0        0 
0            0 
0                0 
0    0 
0        0 
0            0 
0                0 
0    0 
1        0 
0            0 
0                0 
0    0 
1        1 
1            1 
0                0 
1    0 
1        1 
0            1 
0                0 
0    0 
1        2 
0            1 
0                0 
0    0 
0        2 
0            1 
0                0 
1    1 
1        3 
1            2 
0                0 
0    1 
1        3 
0            2 
1                0 
0    1 
1        4 
0            2 
0                0 
0    1 
0        4 
0            2 
0                0 
1    2 
0        4 
1            3 
0                0 
0    2 
0        4 
0            3 
0                0 
1    3 
1        5 
0            3 
0                0 
0    3 
0        5 
0            3 
1                0 
0    3 
0        5 
1            4 
1                1 
1    3 
0        5 
1            4 
0                1 
1    4 
1        6 
0            4 
0                1 
1    4 
1        6 
1            4 
1                1 
0    4 
0        6 
0            4 
0                1 
0    4 
0        6 
0            4 
0                1 
0    4 
0        6 
0            4 
1                2 
0    4 
1        6 
1            4 
0                2 
0    4 
1        7 
0            4 
0                2 
0    4 
0        7 
0            4 
0                2 
0    4 
0        7 
0            4 
0                2 
0    4 
1        7 
0            4 
1                2 
0    4 
0        7 
1            5 
0                2 
1    4 
1        7 
0            5 
0                2 
0    4 
0        7 
0            5 
0                2 
0    4 
1        7 
0            5 
0                2 
0    4 
0        7 
1            6 
1                3 
0    4 
0        7 
1            6 
0                3 
0    4 
0        7 
0            6 
0                3 
0    4 
0        7 
0            6 
0                3 
0    4 
1        8 
1            7 
0                3 
0    4 
0        8 
1            7 
0                3 
0    4 
0        8 
0            7 
0                3 
0    4 
1        8 
0            7 
0                3 
0    4 
0        8 
1            8 
0                3 
1    4 
0        8 
1            8 
0                3 
1    5 
1        9 
0            8 
1                4 
0    5 
0        9 
0            8 
0                4 
0    5 
0        9 
0            8 
1                5 
0    5 
0        9 
0            8 
0                5 
1    6 
1        10 
1            9 
0                5 
0    6 
1            9 
0                5 
1    7 
1            10 
0                5 
0    7 
0                5 
0    7 
1                6 
1    7 
0                6 
1    8 
0                6 
1    8 
1                6 
0    8 
0                6 
0    8 
0                6 
0    8 
0                6 
0    8 
0                6 
0    8 
1                7 
1    8 
0                7 
0    8 
1                8 
0    8 
0                8 
0    8 
1                9 
0    8 
0                9 
0    8 
0                9 
0    8 
1                9 
1    9 
0                9 
0    9 
1                9 
0    9 
0                9 
1    9 
0                9 
0    9 
0                9 
0    9 
0                9 
0    9 
1                10 
0    9 
0    9 
1    9 
0    9 
0    9 
0    9 
0    9 
1    10

die räder laufen unterschiedlich an, bleiben umterschiedlich stehen...

ich bin sicher, dass das an der struktur des vervierfachten codes liegt, an den einzelnen abfragen des zustandes der vier encoder und der davon abhängigen reaktionen. So kann die struktur also nicht bleiben, ich habe aber absolut keinen plan wie es anders sein könnte?

Ist der ansatz überhaupt richtig? Geht sowas überhaupt ohne interrupts? Wäre mir schon lieber, weil ich mich damit nicht gut auskenne und denke auch, dass das auslesen von 4 encodern und das gleichzeitige betreiben von vier motoren schon recht unkompliziert(?) ist und mit "normalem" code machbar sein müsste...