Ferngesteuertes Auto per Android oder Laptop steuern

International Deutsch
1

Hallo Community,

ich möchte mit einem Arduino Mega ein ferngesteuertes Auto steuern.
Im Auto sind zwei Servos verbaut. Zusätzlich möchte ich einen 3 Achsen Beschleunigungssensor auswerten.

Der Arduino soll eine Funk-Verbindung mit dem Laptop oder Android Gerät herstellen.
Ich würde eine Wlan Verbindung bevorzugen, bin über andere Ideen sehr erfreut.

Meine Überlegung ist, dass der Arduino eine Webseite erzeugt (Webserver), auf die der PC/Android mit einem Programm zugreift. Die Seite müsste auch einfach auszulesen sein, so das die Werte im Hintergrund geloggt werden können.

Für die Android Version möchte ich vier Tasten auf dem Display anzeigen, die für Vorwärts, Rückwärts, links lenken und rechts lenken genutzt werden.
Zusätzlich sollen die Werte des Beschleunigungssensors angezeigt werden.
Dies könnte auchh ohne App passieren, wenn der Arduino eine angepasste Webseite erzeugt auf der dieses Funktionen bereits vorhanden sind.

Für den Laptop soll die Schaltung auf Tastatur umgeschaltet werden können. Sodass über die Pfeiltasten oder "WASD" gelenkt werden kann.

Gruß Rauschi_7

2

Rauschi_7:
ich möchte mit einem Arduino Mega ein ferngesteuertes Auto steuern.....

Gruß Rauschi_7

Ja, das hört sich doch alles toll an, was du möchtest.

Ich sehe aber nirgens, wie du es lösen willst.
kein Sketch, kein Schaltbild, keine Links zu Bauteilen usw....

Wie sollen wir das verstehen ?

Oder möchtest du, das wir das für dich machen ?

Evtl. ist es ja genau so spannend, wie mit deinem "Drohnenprojekt" ?

3

Oh da habe ich wohl etwas vergessen...

Danke für die schnelle Antwort.

Ich verwende einen Arduino Mega.

Für die Wifi Verbindung möchte ich ein ESP8266 Modul benutzen.

Als erster Sensor soll ein MPU 6050 Modul angeschlossen werden. Später sollen noch ein paar Ultraschall Sensoren hinzu kommen.

Ich hoffe das die Verbindung auch über eine größere Entfernung gut funktioniert.

Der Sketch wird zum Wochenende hin hochgeladen. (Mal gucken wie das zeitlich passt.)

Ich möchte das schon selbst machen, habe aber gerade einen Denkfehler in der Konstruktion deshalb frage ich hier nach.
Mein Hauptproblem ist, wie ich von dem Android Gerät auf den Arduino Daten sende. Wobei das einfacher ist als von einem PC auf den Arduino Daten zu senden. (Ich weiß das es möglich ist, habe da aber gerade meine Schwierigkeiten mit).

Mein Grundgedanke:
1.Der Arduino erstellt zwei Webseiten:

  1. Seite
    Zur Verwendung mit Android Geräten
    Auf der Seite sollen vier Taster angezeigt werden (gas/Bremse/rechts/links).
    Zusätzlich wären ein paar Schalter, mit denen Lampen oder andere Sonderfunktionen geschaltet werden, sehr interessant.

  2. Seite
    Zur Verwendung mit einem Laptop
    Die Seite muss so aufgebaut sein, dass ein Programm hier einfach Werte eingeben kann.

Mit TCP und IP kenne ich mich ganz gut aus. Ich habe Probleme beim Verarbeiten der Daten.

4

Ich würds per UDP machen. Funktioniert bei mir Tadellos. Dazu nen ESP. Problem ist halt der ESP hat nur einen Analog in. D.h. du brauchst noch nen Multiplexer. Ist aber alles kein großes Problem.

5

Hi

an UDP hatte ich noch nicht gedacht.

Habe mir jetzt ein esp8266 geholt, komme da aber nicht wirklich weiter.

Das Modul kommuniziert über RX und TX.

Leider klappt das nicht so wie ich es will.

Habe es leider nicht anders geschafft, die Schaltung hier zu posten.

Ich hoffe ihr versteht meinen Aufbau.

Ich benutze einen Level Shifter um die 5 Volt Signale auf 3,3 Volt zu regulieren und anders herum.
Auf dem Display (20 Zeichen x 4 Spalten) sollen später Fehler und Ereignisse angezeigt werden. Aktuell sollen alle Befehle, die an die Servos gesendet werden, angezeigt werden. Die Werte des 3 Achsen Beschleunigungssensor sollen an das Smartphone/ den PC gesendet werden und in der Software angezeigt werden.
Das Auto wird von einem 7,2 V Akku gespeist, welche vom Motor Steuergerät auf 5 Volt herunter geregelt werden.

Das Steuergerät vom Motor reagiert auf Servobefehle (gleiche Signale, wie die Signale für einen Servo).
Aus diesem Grund habe ich zwei Servos in dem Schaltplan aufgeführt.

Die spätere Stromversorgung des ESP8266 übernehmen zwei AA Batterien.

Für Das Projekt verwende ich einen Arduino Mega.

Später sollen Abstandsmesser hinzu kommen, die kontrollieren, dass der Wagen nicht über einen "Abgrund" fährt oder mit einer Wand kollidiert.

Auch finde ich das Thema FPV interessant, hätte auch noch eine kleine Actioncam hier rumliegen.
Das ist aber Zukunftsmusik.

Als erstes bräuchte ich ein paar Ansätze, wie ich den ESP8266 mit dem Arduino kommunizieren lasse und im nähsten Schritt das Smartphone mit dem Arduino.

Danke schon mal

6

Das kommt darauf an was du genau vor hast. Willst du ne Website bauen auf der das ganze steuerbar ist würde ich die beiden z.B. per I2C verbinden. Dann hast du genug speicher auf dem ESP um die Website darzustellen etc. und die Befehler weiter zu geben. Direkt kannst du die Befehle dann natürlich über RX/TX senden. Da gibts eigentlich genug Beispiele. Wichtig ist hier aber, dass du dann die Firmware nicht runter löschst.

7

Hallo Heimdall,

Ich möchte auf dem Smartphone eine kleine App oder eine Webseite, die in Echtzeit über Tasten Befehle an die Servos senden. Zusätzlich sollen Werte angezeigt werden.

Die Idee mit der App ist vom Benutzen schöner, die Webseite wird aber imo leichter sein.

Könntest du mir den Vorteil der beiden Möglichkeiten erläutern.

8

Nein das ist nicht schwer. Für Android gibt es zich UDP sende Apps, auch Die Frage ist eben ob sie deinen Ansprüchen genügen, oder ob du dir da selber was bauen willst. Das wäre dann schon etwas schwerer. Aber ne HTML Seite zum steuern ist auch nicht super schwer, du musst allerdings die Befehle abfangen. Fang halt erstmal mit UDP an. Erweitern kannst du es ja immer noch.

9

Danke für die Info mit der App.
Wie kann ich mit dem ESP8266 über I2C kommunizieren?

Ich verstehe das ESP8266 noch nicht so ganz.
Wenn ich dort ein Programm zum laufen bekommen will (z.B. Webserver) muss ich die Firmware überschreiben.

Dann verstehe ich das mit I2C nicht ganz. Gibt es eine Möglichkeit die Adressen der angeschlossenen Geräte heraus zu bekommen? Der I2C Scanner hat nicht funktioniert bei meinem ESP8266.

Ich möchte das der Arduino ein eigenes WLan erzeugt mit festgelegtem Namen und festgelegtem Passwort in das ich mehrere Geräte einwählen kann.

Ich benutze einen 8 Kanal Level Shifter für den ESP8266 der alle Signale (5Volt, SDA und SCL) auf 3,3 Volt Signale regelt.

Ist das soweit richtig und könnt ihr mir damit helfen.

10

Du kannst den ESP direkt an den PC anschliessen und mit der Arduino IDE bespielen. Gibt da genug Beispiele für. Dann würde ich mit dem ESP den Wlan Ap aufbauen. Da gibts Beispiel Skripte in der IDE. Mach doch erstmal das. Dann musste du in beiden Geräten I2C aktivieren. Standardmässig müsste das deaktiviert sein. Sende Daten zwischen beiden Geräten hin und her und dann bau den UDP Empfang auf.

11

Mein ESP 8266 01 Modul ist defekt, daher konnte ich nicht darauf zugreifen. Ein neues Modul ist bestellt und sollte diese Woche noch ankommen. Dann kann es mit dem Programmieren von vorne beginnen.

Danke für die vielen nützlichen und hilfreichen Beiträge.

Gruß Rauschi_7

12

Rauschi_7:
Mein ESP 8266 01 Modul ist defekt, daher konnte ich nicht darauf zugreifen. Ein neues Modul ist bestellt und sollte diese Woche noch ankommen. Dann kann es mit dem Programmieren von vorne beginnen.

Wieso von vorne ?

Das was du fertig hast, kannst du weiter nutzen. Ist doch sicher noch auf dem Rechner drauf.

13

Da hast du recht.

Habe jetzt ein NodeMCU mit ESP 12F Modul.

Aus irgendeinem Grund, der sich mir nicht erschließen will, erkennt mein Laptop das Modul nicht.
Code kann ich nicht hochladen auf das Modul und per AT Befehlen mit Arduino wird jeder Befehl als Fehler angezeigt.

Ich habe mehrere USB Kabel ausprobiert, einen anderen FTDI und eine externe Stromquelle, habe bisher das Modul nicht zum Laufen bekommen.

14

Hi

Auf das ESP8266 12F Modul kann ich per AT Befehlen zugreifen.
Leider kann ich mit den Arduino IDE keinen Code auf das Modul übertragen.
Die IDE meldet, dass das Board nicht erkannt wird.

Der ESC des ferngesteuerten Autos lässt sich leider nicht ansteuern, obwohl er über die Servo Bibliothek angesteuert werden müsste, da der Anschluss der gleiche wie der des Servos ist.
Der ESC ist ein TEU 101BK von Tamiya. Der ESC kann programmiert werden, wobei mehrere Werte, die im Internet angegeben waren, ausprobiert wurden.

Hier der Code für die LED Beleuchtung und die Lenkung/Steuerung per Laptop über USB:

//LED Ausgänge
int LED_BLK_L = 22; //Blinker links         (Gelb)
int LED_BLK_R = 23; //Blinker rechts        (Gelb)
int LED_SW = 24;    //Scheinwerfer Front    (Weiß)
int LED_RL = 25;    //Rücklichter hinten    (Rot)
int LED_BRL = 26;   //Bremslicht hinten     (Rot)
int LED_RWL = 27;   //Rückwärtslicht hinten (Weiß)

int LED_BL1 = 30;
int LED_BL2 = 31;
int LED_BL3 = 32;
int LED_BL4 = 33;

int SW = 0;
boolean ValueSW = LOW;
int RL = 0;
boolean ValueRL = LOW;
int BRL = 0;
boolean ValueBRL = LOW;
int RWL = 0;
boolean ValueRWL = LOW;

//Blinkschaltung

//Blinker links
int BLK_L = 0; 
boolean ValueBLK_L = LOW;
unsigned long previousMillisBLK_L = 0;
unsigned long IntervalBLK = 250;  //Intervall für beide Blinker

//Blinker rechts
int BLK_R = 0; 
boolean ValueBLK_R = LOW;
unsigned long previousMillisBLK_R = 0;

//Blaulicht blinken
int BL = 0;
boolean ValueBL1 = LOW;
boolean ValueBL2 = LOW;
boolean ValueBL3 = LOW;
boolean ValueBL4 = LOW;
unsigned long previousMillisBL = 0;
unsigned long IntervalBL = 150;
int StatusBL = 1;



//Motorsteuerung
#include <Servo.h>
Servo Lenkung;
Servo Motor;

//Variable zum auslesen der Serial.
char Wert;

void setup() {
  // put your setup code here, to run once:
pinMode(LED_BLK_L,OUTPUT); //Linker Blinker
pinMode(LED_BLK_R,OUTPUT); //Rechter Blinker
pinMode(LED_SW,OUTPUT);    //Scheinwerfer Front
pinMode(LED_RL,OUTPUT);    //Rücklichter
pinMode(LED_BRL,OUTPUT);   //Bremslicht hinten
pinMode(LED_RWL,OUTPUT);   //Rückwärtslicht hinten
pinMode(LED_BL1,OUTPUT);   //Blaulicht 1
pinMode(LED_BL2,OUTPUT);   //Blaulicht 2
pinMode(LED_BL3,OUTPUT);   //Blaulicht 3
pinMode(LED_BL4,OUTPUT);   //Blaulicht 4

Lenkung.attach(36);
Motor.attach(2);

Serial.begin(9600);
Serial.println("Baja-King: ONLINE");
}

void loop() {
  // put your main code here, to run repeatedly:
if(Serial.available()){
  Wert = Serial.read();


  if(Wert == 'a'){
    BLK_L = 1;
    BLK_R = 1;
    SW = 1;
    RL = 1;
    BRL = 1;
    RWL = 1;
    BL = 1;
    
  }
  if(Wert == 's'){
    BLK_L = 0;
    BLK_R = 0;
    SW = 0;
    RL = 0;
    BRL = 0;
    RWL = 0;
    BL = 0;
  }
    
  if(Wert == 'b'){
    BL = 1;
    Serial.println("Blaulicht an");
  }
  if(Wert == 'n'){
    BL = 0;
    Serial.println("Blaulicht aus");
  }
  if(Wert == 'l'){
    SW = 1;
    RL = 1;
    Serial.println("Scheinwerfer an");
  }
  if(Wert == 'k'){
    SW = 0;
    RL = 0;
    Serial.println("Scheinwerfer aus");
  }
  if(Wert == '8'){          //Vorwärts
    Motor.write(150);
    Lenkung.write(90);
    BLK_L = 0;
    BLK_R = 0;
    BRL = 0;
    RWL = 0;
    Serial.println("Vorwärts");
  }
  if(Wert == '5'){          //Bremsen
    Motor.write(90);
    Lenkung.write(90);
    BLK_L = 0;
    BLK_R = 0;
    BRL = 1;
    RWL = 0;
    Serial.println("Bremsen");
  }
  if(Wert == '2'){          //Rückwärts
    Motor.write(50);
    Lenkung.write(90);
    BLK_L = 0;
    BLK_R = 0;
    BRL = 0;
    RWL = 1;
    Serial.println("Rückwärts");
  }
  if(Wert == '4'){          //Links
    Lenkung.write(50);
    BLK_L = 1;
    BLK_R = 0;
    Serial.println("Links");
  }
  if(Wert == '6'){            //Rechts
    Lenkung.write(130);
    BLK_R = 1;
    BLK_L = 0;
    Serial.println("Rechts");
  }
}

//Lichtsteuerung

if(SW == 0){
  ValueSW = LOW;
}
if(SW == 1){
  ValueSW = HIGH;
}
if(RL == 0){
  ValueRL = LOW;
}
if(RL == 1){
  ValueRL = HIGH;
}
if(BRL == 0){
  ValueBRL = LOW;
}
if(BRL == 1){
  ValueBRL = HIGH;
}
if(RWL == 0){
  ValueRWL = LOW;
}
if(RWL == 1){
  ValueRWL = HIGH;
}


//Blinklichtsteuerung
if(BLK_L == 0){
  ValueBLK_L = LOW;
}
if(BLK_L == 1){
  if(millis() - previousMillisBLK_L > IntervalBLK){
    previousMillisBLK_L = millis();

    //LED Zustand wechsseln
    ValueBLK_L = !ValueBLK_L;
  }
}

if(BLK_R == 0){
  ValueBLK_R = LOW;
}
if(BLK_R == 1){
  if(millis() - previousMillisBLK_R > IntervalBLK){
    previousMillisBLK_R = millis();

    ValueBLK_R = !ValueBLK_R;
  }
}

if(BL == 0){
  ValueBL1 = LOW;
  ValueBL2 = LOW;
  ValueBL3 = LOW;
  ValueBL4 = LOW; 
}
if(BL == 1){
  if(StatusBL == 1){
    if(millis() - previousMillisBL > IntervalBL){
      StatusBL = 2;
      previousMillisBL = millis();
      ValueBL1 = !ValueBL1;
      ValueBL2 = LOW;
      ValueBL3 = LOW;
      ValueBL4 = LOW;
    }
  }
  if(StatusBL == 2){
    if(millis() - previousMillisBL > IntervalBL){
      StatusBL = 3;
      previousMillisBL = millis();
      ValueBL2 = !ValueBL2;
      ValueBL1 = LOW;
      ValueBL3 = LOW;
      ValueBL4 = LOW;
    }
  }
  if(StatusBL == 3){
    if(millis() - previousMillisBL > IntervalBL){
      StatusBL = 4;
      previousMillisBL = millis();
      ValueBL3 = !ValueBL3;
      ValueBL1 = LOW;
      ValueBL2 = LOW;
      ValueBL4 = LOW;
    }
  }
  if(StatusBL == 4){
    if(millis() - previousMillisBL > IntervalBL){
      StatusBL = 1;
      previousMillisBL = millis();
      ValueBL4 = !ValueBL4;
      ValueBL1 = LOW;
      ValueBL2 = LOW;
      ValueBL3 = LOW;
    }
  }
}



//LED Ausgänge schalten

digitalWrite(LED_SW,ValueSW);
digitalWrite(LED_RL,ValueRL);
digitalWrite(LED_BRL,ValueBRL);
digitalWrite(LED_RWL,ValueRWL);

digitalWrite(LED_BLK_L,ValueBLK_L);
digitalWrite(LED_BLK_R,ValueBLK_R);

digitalWrite(LED_BL1,ValueBL1);
digitalWrite(LED_BL2,ValueBL2);
digitalWrite(LED_BL3,ValueBL3);
digitalWrite(LED_BL4,ValueBL4);

}