Robot Car - variable Geschwindigkeitskontrolle

daria87 · August 23, 2025, 3:36pm

Moin Moin,

also ich hab mir endlich einen funktionfähigen Bluetooth Ultrasensor Robot Car programmiert Nun würde ich gerne noch eine Variable Geschwindigkeitskontrolle einbauen. Mein RC-Controller hat eine Servokontrolle mit Bezeichnung J oder K inkl. Der Bereich 0 bis 180 würde mir ausreichen und so hab ich mir gedacht, man könnte es ja vielleicht umfunktionieren. Also wenn ich Servokontrolle J auf 70 schiebe, fährt das Auto "70" usw.
Nun ist die Frage, wie bekomme ich den Wert aus J gelesen und in eine Variable geschrieben, die motor1.setSpeed(120); übernimmt. Ich weiß nicht wie ich Buchstaben J einen Wertebereich hinzufügen soll.
Wenn ich bis jetzt vom SerMo erhalte ist

FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A
FailChar: 4A

#include <AFMotor.h>
#include <Arduino.h>
#include <HCSR04.h>
#include <SoftwareSerial.h>

SoftwareSerial BlueTooth(10, 11);  // RX, TX
byte triggerPin = 9;
byte echoPin = 7;
int duration, distance;
int number;
char BT_input;
char oldInput;


AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
unsigned char smile[] = { 0x00, 0x00, 0x1c, 0x02, 0x02, 0x02, 0x5c, 0x40, 0x40, 0x5c, 0x02, 0x02, 0x02, 0x1c, 0x00, 0x00 };
unsigned char herz[] = { 0x00, 0x00, 0x00, 0x0c, 0x12, 0x21, 0x41, 0x82, 0x41, 0x21, 0x12, 0x0c, 0x00, 0x00, 0x00, 0x00 };
unsigned char vor[] = { 0x00, 0x00, 0x02, 0x04, 0x09, 0x12, 0x24, 0x48, 0x90, 0x48, 0x24, 0x12, 0x09, 0x04, 0x02, 0x00 };
#define SCL_Pin A4
#define SDA_Pin A5
void setup() {
  Serial.begin(57600);
  Serial.println(F("Start..."));
  BlueTooth.begin(9600);
  pinMode(SCL_Pin, OUTPUT);
  pinMode(SDA_Pin, OUTPUT);
}

void loop() {
  motor1.setSpeed(120);
  motor2.setSpeed(120);
  motor3.setSpeed(120);
  motor4.setSpeed(120);
  pinMode(triggerPin, OUTPUT);
  pinMode(echoPin, INPUT);
bluetooth();
getData();
 
}
void getData() {
  while (BlueTooth.available()) {
    //char myChar = Serial.read();
    char myChar = BlueTooth.read();

    if (isAlpha(myChar)) {
      myChar = ucase(myChar);
      switch (myChar) {
        case 'Y':
        case 'X':
        case 'B':  //backward
        case 'F':  //forward
        case 'L':  //left
        case 'R':  //right
        case 'S':  //stop
          Serial.print(F("Input Char: "));
          Serial.println(myChar);
          BT_input = myChar;
          break;  //gültiges Zeichen
        default:
          if (myChar >= ' ') {
            Serial.print(F("FailChar: "));
            Serial.println(myChar, HEX);
            BT_input = 'S';
          }
      }
    }
  }
  if (oldInput != BT_input) {
    car_Stop();
    delay(20);  // kurze Pause schont die Antriebe!
    oldInput = BT_input;
  }
}
char ucase(const char c) {
  if (c >= 'a' && c <= 'z') {
    return (c + ('A' - 'a'));
  }
  return c;
}
void bluetooth() {
getData();
  switch (BT_input) {
    case 'X': switchdrive();break;
    case 'Y': bluetooth();break;

    case 'B': car_back(); break;

    case 'F': car_front(); break;

    case 'L': car_left(); break;

    case 'R': car_right(); break;

    case 'S': car_Stop(); break;
  }
}
void geschwindigkeit (){
  getData();
  if (BT_input='K')
}

void switchdrive() {
  distance = 0;
  digitalWrite(triggerPin, LOW);
  delayMicroseconds(4);
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);

  duration = pulseIn(echoPin, HIGH);
  distance = round(duration * .0343) / 2;
  Serial.print("Distance: ");
  Serial.println(distance);
  delay(100);
  switch (distance) {
    case 1 ... 15:
      car_front();
      Serial.println("zurueck");
      delay(1200);
      drive();
      Serial.println(number);
      matrix_display(herz);
      break;
    case 16 ... 30:
      motor1.setSpeed(90);
      motor2.setSpeed(90);
      motor3.setSpeed(90);
      motor4.setSpeed(90);
      car_back();
      Serial.println("langsam vor");
      matrix_display(smile);
      break;
    case 31 ... 45:
      car_back();
      Serial.println("Vorwaerts");
      matrix_display(vor);
      break;
    default:
      car_back();
      Serial.println("default");
      matrix_display(vor);
      break;
  }
}
void drive() {
  number = random(3);
  if (number == 1) {
    car_left();
    delay(1500);
  }
  else {
    car_right();
    delay(1500);
  }
}
void car_back() {
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void car_front() {
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void car_left() {
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void car_right() {
  motor3.run(RELEASE);
  motor4.run(RELEASE);
  motor1.run(FORWARD);
  motor2.run(FORWARD);
}
void car_Stop() {
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void matrix_display(unsigned char matrix_value[]) {
  IIC_start();     //the function that calls the data transfer start condition
  IIC_send(0xc0);  //select address

  for (int i = 0; i < 16; i++)  //the pattern data is 16 bytes
  {
    IIC_send(matrix_value[i]);  //Transmit the data of the pattern
  }
  IIC_end();  //End pattern data transmission
  IIC_start();
  IIC_send(0x8A);  //Display control, select 4/16 pulse width
  IIC_end();
}
//Conditions under which data transmission begins
void IIC_start() {
  digitalWrite(SDA_Pin, HIGH);
  digitalWrite(SCL_Pin, HIGH);
  delayMicroseconds(3);
  digitalWrite(SDA_Pin, LOW);
  delayMicroseconds(3);
  digitalWrite(SCL_Pin, LOW);
}
//Indicates the end of data transmission
void IIC_end() {
  digitalWrite(SCL_Pin, LOW);
  digitalWrite(SDA_Pin, LOW);
  delayMicroseconds(3);
  digitalWrite(SCL_Pin, HIGH);
  delayMicroseconds(3);
  digitalWrite(SDA_Pin, HIGH);
  delayMicroseconds(3);
}
//transmit data
void IIC_send(unsigned char send_data) {
  for (byte mask = 0x01; mask != 0; mask <<= 1)  //Each byte has 8 bits and is checked bit by bit starting at the lowest level
  {
    if (send_data & mask) {  //Sets the high and low levels of SDA_Pin depending on whether each bit of the byte is a 1 or a 0
      digitalWrite(SDA_Pin, HIGH);
    } else {
      digitalWrite(SDA_Pin, LOW);
    }
    delayMicroseconds(3);
    digitalWrite(SCL_Pin, HIGH);  //Pull the clock pin SCL_Pin high to stop data transmission
    delayMicroseconds(3);
    digitalWrite(SCL_Pin, LOW);  //pull the clock pin SCL_Pin low to change the SIGNAL of SDA
  }
}

combie · August 23, 2025, 3:41pm

Sehe keinen Wertebereich!

daria87 · August 23, 2025, 4:59pm

Im Grunde müsste er ja zählen wie oft 4A rein kommt.

combie · August 23, 2025, 8:36pm

wieOftJ++;

my_xy_projekt · August 23, 2025, 9:14pm

????

Das auch seinen Sinn!!!

/home/user1/arduino-1.8.19/portable/sketchbook/libraries/Adafruit-Motor-Shield-library-master/AFMotor.cpp: In function 'void initPWM3(uint8_t)':
/home/user1/arduino-1.8.19/portable/sketchbook/libraries/Adafruit-Motor-Shield-library-master/AFMotor.cpp:230:30: warning: unused parameter 'freq' [-Wunused-parameter]
 inline void initPWM3(uint8_t freq) {
                              ^~~~
/home/user1/arduino-1.8.19/portable/sketchbook/libraries/Adafruit-Motor-Shield-library-master/AFMotor.cpp: In function 'void initPWM4(uint8_t)':
/home/user1/arduino-1.8.19/portable/sketchbook/libraries/Adafruit-Motor-Shield-library-master/AFMotor.cpp:285:30: warning: unused parameter 'freq' [-Wunused-parameter]
 inline void initPWM4(uint8_t freq) {
                              ^~~~
/home/user1/arduino-1.8.19/portable/sketchbook/libraries/Adafruit-Motor-Shield-library-master/AFMotor.cpp: In member function 'uint8_t AF_Stepper::onestep(uint8_t, uint8_t)':
/home/user1/arduino-1.8.19/portable/sketchbook/libraries/Adafruit-Motor-Shield-library-master/AFMotor.cpp:588:23: warning: comparison is always true due to limited range of data type [-Wtype-limits]
     if ( (currentstep >= 0) && (currentstep < MICROSTEPS)) {
           ~~~~~~~~~~~~^~~~
/home/user1/arduino-1.8.19/portable/sketchbook/libraries/Adafruit-Motor-Shield-library-master/AFMotor.cpp:626:22: warning: comparison is always true due to limited range of data type [-Wtype-limits]
     if ((currentstep >= 0) && (currentstep < MICROSTEPS))
          ~~~~~~~~~~~~^~~~

Der hier ist spannend:

Und wenn Du nicht willst, dass es funktionert, dann ist dass hier richtig:

daria87:

void loop() {
  motor1.setSpeed(120);
  motor2.setSpeed(120);
  motor3.setSpeed(120);
  motor4.setSpeed(120);
  pinMode(triggerPin, OUTPUT);
  pinMode(echoPin, INPUT);
bluetooth();
getData();

Darf der Compiler jetzt aussuchen, wann getData() ausgeführt wird um Ergebnisse zu liefern?

Der Code ist vermurkst.
Ich habs trotzdem versucht.

#include <AFMotor.h>
#include <Arduino.h>
#include <HCSR04.h>
#include <SoftwareSerial.h>

SoftwareSerial BlueTooth(10, 11);  // RX, TX
byte triggerPin = 9;
byte echoPin = 7;
int duration, distance;
int number;
char BT_input;
char oldInput;

constexpr uint8_t defaultSpeed {90};
uint8_t mySpeed = defaultSpeed;
constexpr bool PLUS {HIGH};
constexpr bool MINUS {!PLUS};

AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
unsigned char smile[] = { 0x00, 0x00, 0x1c, 0x02, 0x02, 0x02, 0x5c, 0x40, 0x40, 0x5c, 0x02, 0x02, 0x02, 0x1c, 0x00, 0x00 };
unsigned char herz[] = { 0x00, 0x00, 0x00, 0x0c, 0x12, 0x21, 0x41, 0x82, 0x41, 0x21, 0x12, 0x0c, 0x00, 0x00, 0x00, 0x00 };
unsigned char vor[] = { 0x00, 0x00, 0x02, 0x04, 0x09, 0x12, 0x24, 0x48, 0x90, 0x48, 0x24, 0x12, 0x09, 0x04, 0x02, 0x00 };
#define SCL_Pin A4
#define SDA_Pin A5

void setup()
{
  Serial.begin(57600);
  Serial.println(F("Start..."));
  BlueTooth.begin(9600);
  pinMode(SCL_Pin, OUTPUT);
  pinMode(SDA_Pin, OUTPUT);
  pinMode(triggerPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop()
{
  getNewDistance();
  bluetooth();
}

void bluetooth()
{
  getData();

  switch (BT_input)
  {
    case 'X': switchdrive(); break;

    // case 'Y': bluetooth(); break;  // Das ist Unsinn

    case 'B': car_back(); break;

    case 'F': car_front(); break;

    case 'L': car_left(); break;

    case 'R': car_right(); break;

    case 'S': car_Stop(); break;

    case 'J': speed_plus(); break;

    case 'K': speed_minus(); break;
  }
}

void getData()
{
  while (BlueTooth.available())
  {
    //char myChar = Serial.read();
    char myChar = BlueTooth.read();

    if (isAlpha(myChar))
    {
      myChar = ucase(myChar);

      switch (myChar)
      {
        case 'Y':
        case 'X':
        case 'B':  //backward
        case 'F':  //forward
        case 'L':  //left
        case 'R':  //right
        case 'S':  //stop
        case 'J':
        case 'K':
          Serial.print(F("Input Char: "));
          Serial.println(myChar);
          BT_input = myChar;
          break;  //gültiges Zeichen

        default:
          if (myChar >= ' ')
          {
            Serial.print(F("FailChar: "));
            Serial.println(myChar, HEX);
            BT_input = 'S';
          }
      }
    }
  }

  if (oldInput != BT_input)
  {
    car_Stop();
    delay(20);  // kurze Pause schont die Antriebe!
    oldInput = BT_input;
  }
}

char ucase(const char c)
{
  if (c >= 'a' && c <= 'z')
  {
    return (c + ('A' - 'a'));
  }

  return c;
}

void speed_plus()
{
  geschwindigkeit(PLUS, 500);
}

void speed_minus()
{
  geschwindigkeit(MINUS, 100);
}

void geschwindigkeit (const bool dir, const uint32_t repeat) // Übergibt die Richtung und die Wiederholrate der Änderung
{
  static bool repeatActive = false;
  static bool lastDir = 0;
  static uint32_t lastTik = 0;

  if (repeatActive)
  {
    if (millis() - lastTik > repeat ||
        dir != lastDir)
    { repeatActive = false; }
  }

  if (repeatActive == false)
  {
    if ((dir == PLUS) && (mySpeed < 254))
    { mySpeed++; }
    else if ((dir == MINUS) && (mySpeed > 0))
    { mySpeed--; }

    /*
      else
      {servoSpeed = defaultSpeed;}
    */
    lastTik = millis();
    repeatActive = true;
  }
}

void getNewDistance()
{
  distance = 0;
  digitalWrite(triggerPin, LOW);
  delayMicroseconds(4);
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = round(duration * .0343) / 2;
  Serial.print("Distance: ");
  Serial.println(distance);
}

void switchdrive()
{
  switch (distance)
  {
    case 1 ... 15:
      car_front();
      Serial.println(F("zurueck"));
      delay(1200);
      drive();
      Serial.println(number);
      matrix_display(herz);
      break;

    case 16 ... 30:
      mySpeed = defaultSpeed;
      car_back();
      Serial.println(F("langsam vor"));
      matrix_display(smile);
      break;

    case 31 ... 45:
      car_back();
      Serial.println(F("Vorwaerts"));
      matrix_display(vor);
      break;

    default:
      car_back();
      Serial.println(F("default"));
      matrix_display(vor);
      break;
  }
}
void drive()
{
  number = random(3);

  if (number == 1)
  {
    car_left();
    delay(1500);
  }
  else
  {
    car_right();
    delay(1500);
  }
}
void setSpeed(const uint8_t mySpeed)
{
  motor1.setSpeed(mySpeed);
  motor2.setSpeed(mySpeed);
  motor3.setSpeed(mySpeed);
  motor4.setSpeed(mySpeed);
}

void car_back()
{
  setSpeed(mySpeed);
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void car_front()
{
  setSpeed(mySpeed);
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void car_left()
{
  setSpeed(mySpeed);
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void car_right()
{
  setSpeed(mySpeed);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
  motor1.run(FORWARD);
  motor2.run(FORWARD);
}
void car_Stop()
{
  mySpeed = 0;
  setSpeed(mySpeed);
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void matrix_display(unsigned char matrix_value[])
{
  IIC_start();     //the function that calls the data transfer start condition
  IIC_send(0xc0);  //select address

  for (int i = 0; i < 16; i++)  //the pattern data is 16 bytes
  {
    IIC_send(matrix_value[i]);  //Transmit the data of the pattern
  }

  IIC_end();  //End pattern data transmission
  IIC_start();
  IIC_send(0x8A);  //Display control, select 4/16 pulse width
  IIC_end();
}
//Conditions under which data transmission begins
void IIC_start()
{
  digitalWrite(SDA_Pin, HIGH);
  digitalWrite(SCL_Pin, HIGH);
  delayMicroseconds(3);
  digitalWrite(SDA_Pin, LOW);
  delayMicroseconds(3);
  digitalWrite(SCL_Pin, LOW);
}
//Indicates the end of data transmission
void IIC_end()
{
  digitalWrite(SCL_Pin, LOW);
  digitalWrite(SDA_Pin, LOW);
  delayMicroseconds(3);
  digitalWrite(SCL_Pin, HIGH);
  delayMicroseconds(3);
  digitalWrite(SDA_Pin, HIGH);
  delayMicroseconds(3);
}
//transmit data
void IIC_send(unsigned char send_data)
{
  for (byte mask = 0x01; mask != 0; mask <<= 1)  //Each byte has 8 bits and is checked bit by bit starting at the lowest level
  {
    if (send_data & mask)    //Sets the high and low levels of SDA_Pin depending on whether each bit of the byte is a 1 or a 0
    {
      digitalWrite(SDA_Pin, HIGH);
    }
    else
    {
      digitalWrite(SDA_Pin, LOW);
    }

    delayMicroseconds(3);
    digitalWrite(SCL_Pin, HIGH);  //Pull the clock pin SCL_Pin high to stop data transmission
    delayMicroseconds(3);
    digitalWrite(SCL_Pin, LOW);  //pull the clock pin SCL_Pin low to change the SIGNAL of SDA
  }
}

daria87 · August 24, 2025, 1:59pm

ja vermurkst kann schon sein, bisher hatte er aber genau das gemacht, was er sollte
getData(); soll nicht mehr von Anfang an, gestartet werden. Er hatte nämlich direkt mit einschalten mit dem Ultrasensor begonnen und das wollte ich so nicht, es sollte erst anfangen, wenn ich Y drücke

my_xy_projekt · August 24, 2025, 2:07pm

Dann muss das aber auch so programmiert werden.
Du kannst nicht die Funktion bluetooth() aufrufen, dort getData() und meinen, dass mit 'Y'buetooth() aufgerufen wird.

daria87 · September 1, 2025, 11:47am

mein aktuelles Problem ist mal wieder, im SerMo macht er alles tippi toppi, aber die Räder drehen nicht bzw im Line Follower funktioniert das vordere rechte und das hintere linke, genauso im Bluetooth <- links und rechts funktionieren exakt die beiden Räder. vor und zurück nichts

#include <AFMotor.h>
#include <Arduino.h>
#include <HCSR04.h>
#include <SoftwareSerial.h>

SoftwareSerial BlueTooth(10, 11);  // RX, TX
byte triggerPin = 9;
byte echoPin = 7;
int duration, distance;
int number;
char BT_input;
char oldInput;
#define R_S 2
#define L_S 4


AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
unsigned char smile[] = { 0x00, 0x00, 0x1c, 0x02, 0x02, 0x02, 0x5c, 0x40, 0x40, 0x5c, 0x02, 0x02, 0x02, 0x1c, 0x00, 0x00 };
unsigned char herz[] = { 0x00, 0x00, 0x00, 0x0c, 0x12, 0x21, 0x41, 0x82, 0x41, 0x21, 0x12, 0x0c, 0x00, 0x00, 0x00, 0x00 };
unsigned char vor[] = { 0x00, 0x00, 0x02, 0x04, 0x09, 0x12, 0x24, 0x48, 0x90, 0x48, 0x24, 0x12, 0x09, 0x04, 0x02, 0x00 };
#define SCL_Pin A4
#define SDA_Pin A5

void setup() {
  Serial.begin(57600);
  Serial.println(F("Start..."));
  BlueTooth.begin(9600);
  pinMode(SCL_Pin, OUTPUT);
  pinMode(SDA_Pin, OUTPUT);
  pinMode(triggerPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  getNewDistance();
  bluetooth();
}

void bluetooth() {
  getData();

  switch (BT_input) {
    case 'X': switchdrive(); break;

    case 'Y': linefollow(); break;

    case 'B': car_back(); break;

    case 'F': car_front(); break;

    case 'L': car_left(); break;

    case 'R': car_right(); break;

    case 'S': car_Stop(); break;
  }
}

void getData() {
  while (BlueTooth.available()) {
    //char myChar = Serial.read();
    char myChar = BlueTooth.read();

    if (isAlpha(myChar)) {
      myChar = ucase(myChar);

      switch (myChar) {
        case 'Y':
        case 'X':
        case 'B':  //backward
        case 'F':  //forward
        case 'L':  //left
        case 'R':  //right
        case 'S':  //stop
        case 'J':
        case 'K':
          Serial.print(F("Input Char: "));
          Serial.println(myChar);
          BT_input = myChar;
          break;  //gültiges Zeichen

        default:
          if (myChar >= ' ') {
            Serial.print(F("FailChar: "));
            Serial.println(myChar, HEX);
            BT_input = 'S';
          }
      }
    }
  }

  if (oldInput != BT_input) {
    car_Stop();
    delay(20);  // kurze Pause schont die Antriebe!
    oldInput = BT_input;
  }
}

char ucase(const char c) {
  if (c >= 'a' && c <= 'z') {
    return (c + ('A' - 'a'));
  }

  return c;
}



void getNewDistance() {
  distance = 0;
  digitalWrite(triggerPin, LOW);
  delayMicroseconds(4);
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = round(duration * .0343) / 2;
  Serial.print("Distance: ");
  Serial.println(distance);
}

void linefollow() {
  int linker_sensor;
  int rechter_sensor;
  int star = 0;


  rechter_sensor = (digitalRead(R_S));
  linker_sensor = (digitalRead(L_S));
  Serial.println(rechter_sensor);
  Serial.println(linker_sensor);
  if (rechter_sensor == 0 && linker_sensor == 0) {
    star = 4;
  } else if (rechter_sensor == 0 && linker_sensor == 1) {
    star = 2;
  } else if (rechter_sensor == 1 && linker_sensor == 0) {
    star = 3;
  } else if (rechter_sensor == 1 && linker_sensor == 1) {
    star = 1;
  }

  switch (star) {
    case 1:
      car_back();
      Serial.println("lf front");
      star = 0;
      matrix_display(vor);
      break;
    case 2:
      car_right();
      Serial.println("lf right");
      star = 0;
      matrix_display(smile);
      break;
    case 3:
      car_left();
      Serial.println("lf left");
      star = 0;
      matrix_display(smile);
      break;
    case 4:
      car_Stop();
      Serial.println("lf stop");
      star = 0;
      matrix_display(herz);
      break;
  }
}
void switchdrive() {
  switch (distance) {
    case 1 ... 15:
      car_front();
      Serial.println(F("zurueck"));
      delay(1200);
      drive();
      Serial.println(number);
      matrix_display(herz);
      break;

    case 16 ... 30:

      car_back();
      Serial.println(F("langsam vor"));
      matrix_display(smile);
      break;

    case 31 ... 45:
      car_back();
      Serial.println(F("Vorwaerts"));
      matrix_display(vor);
      break;

    default:
      car_back();
      Serial.println(F("default"));
      matrix_display(vor);
      break;
  }
}
void drive() {
  number = random(3);

  if (number == 1) {
    car_left();
    delay(1500);
  } else {
    car_right();
    delay(1500);
  }
}

void car_back() {
  motor1.setSpeed(150);
  motor2.setSpeed(150);
  motor3.setSpeed(150);
  motor4.setSpeed(150);
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void car_front() {
  motor1.setSpeed(150);
  motor2.setSpeed(150);
  motor3.setSpeed(150);
  motor4.setSpeed(150);
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void car_left() {
  motor1.setSpeed(0);
  motor2.setSpeed(0);
  motor3.setSpeed(150);
  motor4.setSpeed(150);
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void car_right() {
  motor1.setSpeed(150);
  motor2.setSpeed(150);
  motor3.setSpeed(0);
  motor4.setSpeed(0);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
  motor1.run(FORWARD);
  motor2.run(FORWARD);
}
void car_Stop() {
  motor1.setSpeed(0);
  motor2.setSpeed(0);
  motor3.setSpeed(0);
  motor4.setSpeed(0);
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void matrix_display(unsigned char matrix_value[]) {
  IIC_start();     //the function that calls the data transfer start condition
  IIC_send(0xc0);  //select address

  for (int i = 0; i < 16; i++)  //the pattern data is 16 bytes
  {
    IIC_send(matrix_value[i]);  //Transmit the data of the pattern
  }

  IIC_end();  //End pattern data transmission
  IIC_start();
  IIC_send(0x8A);  //Display control, select 4/16 pulse width
  IIC_end();
}
//Conditions under which data transmission begins
void IIC_start() {
  digitalWrite(SDA_Pin, HIGH);
  digitalWrite(SCL_Pin, HIGH);
  delayMicroseconds(3);
  digitalWrite(SDA_Pin, LOW);
  delayMicroseconds(3);
  digitalWrite(SCL_Pin, LOW);
}
//Indicates the end of data transmission
void IIC_end() {
  digitalWrite(SCL_Pin, LOW);
  digitalWrite(SDA_Pin, LOW);
  delayMicroseconds(3);
  digitalWrite(SCL_Pin, HIGH);
  delayMicroseconds(3);
  digitalWrite(SDA_Pin, HIGH);
  delayMicroseconds(3);
}
//transmit data
void IIC_send(unsigned char send_data) {
  for (byte mask = 0x01; mask != 0; mask <<= 1)  //Each byte has 8 bits and is checked bit by bit starting at the lowest level
  {
    if (send_data & mask)  //Sets the high and low levels of SDA_Pin depending on whether each bit of the byte is a 1 or a 0
    {
      digitalWrite(SDA_Pin, HIGH);
    } else {
      digitalWrite(SDA_Pin, LOW);
    }

    delayMicroseconds(3);
    digitalWrite(SCL_Pin, HIGH);  //Pull the clock pin SCL_Pin high to stop data transmission
    delayMicroseconds(3);
    digitalWrite(SCL_Pin, LOW);  //pull the clock pin SCL_Pin low to change the SIGNAL of SDA
  }
}

wwerner · September 1, 2025, 12:40pm

Du hattest doch schon ganz oft Wackelkontakte. Ist das ausgeschlossen? Hast du die Spannungen mal mit einem Multimeter gemessen? Die Treiber mal ohne µC getestet?

Du musst einfach systematisch suchen.

Ich habe jetzt nicht in den Sketch geschaut

Wozu eigentlich eigene IIC Funktionen?

Und benutze bitte mal Strg-T in der IDE

daria87 · September 1, 2025, 12:55pm

So ich benutze ein 8x16 LED Dioden "Board" und das war der dazu funktionierende Code, also keinen besonderen Grund warum IIC

Ich hab mal Multimeter rangehalten, wenn das eine Rad dreht bekommt es 5,5V, ansonsten sind alle Werte bei 0. Das die Räder nicht geschalten haben, wusste ich aber auch so schon, weil kein Schaltgeräusch

Mal ne (wahrscheinlich) doofe Frage. Was würde passieren, wenn einfach zuviel dran hängt und die 9V evtl. nicht ausreichen? Ich vermute die Batterien sind sehr schnell alle und ein Teil der Funktion ist nicht gegeben?

Kabel zu den Motoren habe ich nochmal alle überprüft, sind auch fest.

Topic		Replies	Views
Bluetooth Car bewegt sich nicht Deutsch	185	943	December 17, 2025
Help needed in adding speed to my project(4WD RC Car) General Guidance	17	2676	May 5, 2021
Brushless Motor steuern über RS232 Schnittstelle Deutsch	28	186	October 1, 2025
Servo - keine Bewegung Deutsch	112	594	July 29, 2025
Schleife mittels Tastendruck verlassen? Deutsch	57	329	September 29, 2025

Robot Car - variable Geschwindigkeitskontrolle

Related topics