Fahrtrichtung eines selbstfahrenden Auto ändern

[Noya11222]

Hallo alle zusammen,

ich habe in der Schule die Aufgabe, ein statchart für ein selbstfahrendes Auto zu implementieren.
Ich habe die Bewegung wie folgt geändert:
[CODE lang="java" title="switch (bewegungsrichtung mit geschwindigkeitsverlangsamung)" highlight="16"]switch (bewegung){
case vor:
if (vor >= 60){ // wenn vorn 60cm oder mehr sind
com.set(0, 100); //vorwärts mit Geschwindigkeit 100 (entspricht 30 cm/s)
}
else if(vor < 60){ //Vorn kleiner 60cm
com.set(0, 80); //vorwärts mit Geschwindigkeit 80 (entspricht 24 cm/s)
if(vor < 30){ //Vorn kleiner 30cm
com.set(0, 50); //vorwärts mit Geschwindigkeit 50 (entspricht 15 cm/s)
if(vor < 20){ //Vorn kleiner 20cm
com.set(0, 25); //vorwärts mit Geschwindigkeit 25 (entspricht 7,5 cm/s)
if(vor < 15){ //Vorn kleiner 15cm
com.set(0, 15); //vorwärts mit Geschwindigkeit 15 (entspricht 4,5 cm/s)
if(vor < 10){ //Vorn kleiner 10cm
com = vorZuZurueck(vor, hinter);
}
}
}
}
}
break;[/CODE]
jetzt weiß ich nur nicht wie ich in Zeile 16 die Richtung von vor auf zurück ändere, da vorZuZuruck ein boolean zurückgibt.

Hier ist der Code für die Funktion:

public static boolean vorZuZurueck(float vor, float hinter){
        if (bewegung != Bewegung.vor) { //Ausgangszustand nicht vorhanden
            return false;
        }
        if (vor < schwellwert && hinter > schwellwert) { //Bedingung von Pfeil
            return true;
        }
        return false; //Bedingung gar nicht erfüllt
    }

Danke für eure Hilfe.

 

[Mart]

wenn du klassen hattest kannst du ein attribut in der klasse setzen um es zu speichern , wenn du keine Klassen hattest könntest du ein static attribut festlegen das du setzt

 

[Noya11222]

hier ist der gesamte Code von der Klasse:

[CODE lang="java" title="gesamte regeln"]//Implementiert alle Regeln für das ordnungsgemäße Fahren des selbstfahrenden Autos

public class Regel {
private static final int schwellwert = 10; // 10cm
private static int werteZaehler = 0;
private static Zustand zustand = Zustand.ON;
private static Bewegung bewegung = Bewegung.stehen;
private static Lenkung lenkung = Lenkung.geradeaus;
private static boolean buttonIsPressed = false;
private static boolean ausnahmeStatus = false;

private Regel(){
throw new IllegalStateException("This is a utility class.");
}

public static List<Integer> rootRules(float vor, float rechts, float hinter, float links){
ArrayList<Integer> com = new ArrayList<>(2); //Slot 0 = fahrBefehl && Slot 1 = lenkBefehl
com.add(0);
com.add(0);

if(!ausnahmeStatus){
execRulesBewegung(vor, rechts, hinter, links);
execRulesLenkung(vor, rechts, links);
exit(buttonIsPressed);

switch (zustand){
case ON:
if (buttonIsPressed = true){
zustand = Zustand.OFF;
break;
}
}

//TODO Zustand in Steuerkommandos umwandeln
switch (lenkung){
case geradeaus:
com.set(1, 0); //Lenkung auf 0
break;
//Lenkung langsam einschlagen rechts
case rechts:
if (rechts < 50){ // rechts kleiner 50cm
com.set(1, -10); //setze Lenkung auf -10 (entspricht 9 Grad links)
if(rechts < 30){ // rechts kleiner 30cm
com.set(1, -30); //setze Lenkung auf -30 (entspricht 27 Grad links)
if(rechts < 20) { // rechts kleiner 20cm
com.set(1, -50); //setze Lenkung auf -50 (entspricht 45 Grad links)
if (rechts < 15) { // rechts kleiner 15cm
com.set(1, -75); //setze Lenkung auf -75 (entspricht 67,5 Grad links)
if (rechts < 10) { // rechts kleiner 10cm
com.set(1, -100); //setze Lenkung auf -100 (entspricht 90 Grad links)
}
}
}
}
}
break;
//Lenkung langsam einschlagen links
case links:
if(links < 50) //links kleiner 50cm
com.set(1, 10); //setze Lenkung auf 10 (entspricht 9 Grad rechts)
if(links < 30){ //links kleiner 30cm
com.set(1, 30); //setze Lenkung auf 30 (entspricht 27 Grad rechts)
if(links < 20){ //links kleiner 20cm
com.set(1, 50); //setze Lenkung auf 50 (entspricht 45 Grad rechts)
if(links < 15){ //links kleiner 15cm
com.set(1, 75); //setze Lenkung auf 75 (entspricht 67,5 Grad rechts)
if(links < 10){ //links kleiner 10cm
com.set(1, 100); //setze Lenkung auf 100 (entspricht 90 Grad rechts)
}
}
}
}
break;
}

switch (bewegung){
case vor:
if (vor >= 60){ // wenn vorn 60cm oder mehr sind
com.set(0, 100); //vorwärts mit Geschwindigkeit 100 (entspricht 30 cm/s)
}
else if(vor < 60){ //Vorn kleiner 60cm
com.set(0, 80); //vorwärts mit Geschwindigkeit 80 (entspricht 24 cm/s)
if(vor < 30){ //Vorn kleiner 30cm
com.set(0, 50); //vorwärts mit Geschwindigkeit 50 (entspricht 15 cm/s)
if(vor < 20){ //Vorn kleiner 20cm
com.set(0, 25); //vorwärts mit Geschwindigkeit 25 (entspricht 7,5 cm/s)
if(vor < 15){ //Vorn kleiner 15cm
com.set(0, 15); //vorwärts mit Geschwindigkeit 15 (entspricht 4,5 cm/s)
if(vor < 10){ //Vorn kleiner 10cm
com = vorwaerts (vor, rechts);
}
}
}
}
}
break;

case stehen:
com.set(0, 0); //Geschwindigkeit auf 0
break;

case zurueck:
if (hinter >= 60){ // wenn hinten 60cm oder mehr sind
com.set(0, -100); //rückwärts mit Geschwindigkeit -100 (entspricht 30 cm/s)
}
else if(hinter < 60){ //Hinten kleiner 60cm
com.set(0, -80); //rückwärts mit Geschwindigkeit -80 (entspricht 24 cm/s)
if(hinter < 30){ //Hinten kleiner 30cm
com.set(0, -50); //rückwärts mit Geschwindigkeit -50 (entspricht 15 cm/s)
if(hinter < 20){ //Hinten kleiner 20cm
com.set(0, -25); //rückwärts mit Geschwindigkeit -25 (entspricht 7,5 cm/s)
if(hinter < 15){ //Hinten kleiner 15cm
com.set(0, -15); //rückwärts mit Geschwindigkeit -15 (entspricht 4,5 cm/s)
if(hinter < 10){ //Hinten kleiner 10cm
com = rueckwaerts (hinter, rechts);
}
}
}
}
}
break;
}
}else{
com.set(0, 0);
com.set(1, 0);
}

return com;
}

private static void execRulesBewegung(float vor, float rechts, float hinter, float links){
if(stehenBleibtStehen(vor, rechts, hinter, links)){
//Regel erfüllt
bewegung = Bewegung.stehen;
return;
}
if(stehenZuVor(vor, hinter)){
//Regel erfüllt
bewegung = Bewegung.vor;
return;
}
if(stehenZuZurueck(vor, hinter)){
//Regel erfüllt
bewegung = Bewegung.zurueck;
return;
}
if(vorZuStehen(vor, rechts, hinter, links)){
//Regel erfüllt
bewegung = Bewegung.stehen;
return;
}
if(zurueckZuStehen(vor, rechts, hinter, links)){
//Regel erfüllt
bewegung = Bewegung.stehen;
return;
}
if(vorZuZurueck(vor, hinter)){
//Regel erfüllt
bewegung = Bewegung.zurueck;
return;
}
if(zurueckZuVor(vor, hinter)){
//Regel erfüllt
bewegung = Bewegung.vor;
return;
}
if(vorBleibtVor(vor, hinter)){
//Regel erfüllt
bewegung = Bewegung.vor;
return;
}
if(zurueckBleibtZurueck(vor, hinter)){
//Regel erfüllt
bewegung = Bewegung.zurueck;
return;
}
}

private static void execRulesLenkung(float vor, float rechts, float links){
if(geradeausZuLinks(rechts, links)) {
//Regel erfüllt
lenkung = Lenkung.links;
return; //es wird keine andere Regel greifen, als gib aktuelle Regel zurück
}
if(linksZuGeradeaus(vor)){
//Regel erfüllt
lenkung = Lenkung.geradeaus;
return; //es wird keine andere Regel greifen, als gib aktuelle Regel zurück
}
if(linksBleibtLinks(vor, rechts, links)){
//Regel erfüllt
lenkung = Lenkung.links;
return; //es wird keine andere Regel greifen, als gib aktuelle Regel zurück
}
if(linksZuRechts(vor, rechts, links)){
//Regel erfüllt
lenkung = Lenkung.rechts;
return; //es wird keine andere Regel greifen, als gib aktuelle Regel zurück
}
if(rechtsZuLinks(vor, rechts, links)){
//Regel erfüllt
lenkung = Lenkung.links;
return; //es wird keine andere Regel greifen, als gib aktuelle Regel zurück
}
if(rechtsBleibtRechts(vor, rechts, links)){
//Regel erfüllt
lenkung = Lenkung.rechts;
return; //es wird keine andere Regel greifen, als gib aktuelle Regel zurück
}
if(rechtsZuGeradeaus(vor)){
//Regel erfüllt
lenkung = Lenkung.geradeaus;
return; //es wird keine andere Regel greifen, als gib aktuelle Regel zurück
}
if(geradeausZuRechts(rechts, links)){
//Regel erfüllt
lenkung = Lenkung.rechts;
return; //es wird keine andere Regel greifen, als gib aktuelle Regel zurück
}
if (geradeausBleibtGeradeaus(rechts, links)){
//Regel erfüllt
lenkung = Lenkung.geradeaus;
return; //es wird keine andere Regel greifen, als gib aktuelle Regel zurück
}
}

private static ArrayList<Integer> vorwaerts(float vor, float rechts){
ArrayList<Integer> com = new ArrayList<>(2);

com.add(0);
com.add(0);

bewegung = Bewegung.vor; // setze Bewegung auf vor

if(rechts < 10){
com.set(1, -100); //setze Lenkung auf 90 Grad links
}else{
com.set(1, 100); //setze Lenkung auf 90 Grad rechts
}

if (vor < 10){
com.set(0, 0); //bleibt sehen
werteZaehler += 1;
if(werteZaehler == 10){
bewegung = Bewegung.vor; //ändere Richtung auf vorwärts
}
}
return com;
}

private static ArrayList<Integer> rueckwaerts(float hinter, float rechts){
ArrayList<Integer> com = new ArrayList<>(2);

com.add(0);
com.add(0);

bewegung = Bewegung.zurueck; // setze Bewegung auf zurück

if(rechts < 10){
com.set(1, -100); //setze Lenkung auf 90 Grad links
}else{
com.set(1, 100); //setze Lenkung auf 90 Grad rechts
}

if (hinter < 10){
com.set(0, 0); //bleibt sehen
werteZaehler += 1;
if(werteZaehler == 10){
bewegung = Bewegung.zurueck; //ändere Richtung auf zurück
}
}
return com;
}

public static boolean geradeausZuLinks(float rechts, float links){
if(lenkung != Lenkung.geradeaus){ //Ausgangszustand nicht vorhanden
return false;
}
if(rechts < schwellwert && links > schwellwert){ //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean linksZuGeradeaus(float vor){
if(lenkung != Lenkung.links){//Ausgangszustand nicht vorhanden
return false;
}
if(vor > schwellwert){ //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean linksBleibtLinks(float vor, float rechts, float links){
if(lenkung != Lenkung.links){//Ausgangszustand nicht vorhanden
return false;
}
if(vor < schwellwert && rechts < schwellwert && links > schwellwert){ //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean linksZuRechts(float vor, float rechts, float links){
if(lenkung != Lenkung.links){//Ausgangszustand nicht vorhanden
return false;
}
if(vor < schwellwert && rechts > schwellwert && links < schwellwert){ //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean rechtsZuLinks(float vor, float rechts, float links){
if(lenkung != Lenkung.rechts){//Ausgangszustand nicht vorhanden
return false;
}
if(vor < schwellwert && rechts < schwellwert && links > schwellwert){ //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean rechtsBleibtRechts(float vor, float rechts, float links){
if(lenkung != Lenkung.rechts){//Ausgangszustand nicht vorhanden
return false;
}
if(vor < schwellwert && rechts > schwellwert && links < schwellwert){ //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean rechtsZuGeradeaus(float vor){
if(lenkung != Lenkung.rechts){//Ausgangszustand nicht vorhanden
return false;
}
if(vor > schwellwert){ //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean geradeausZuRechts(float rechts, float links) {
if (lenkung != Lenkung.geradeaus) { //Ausgangszustand nicht vorhanden
return false;
}
if (rechts > schwellwert && links < schwellwert) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean geradeausBleibtGeradeaus(float rechts, float links){
if (lenkung != Lenkung.geradeaus) { //Ausgangszustand nicht vorhanden
return false;
}
if (rechts > schwellwert && links > schwellwert) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean stehenBleibtStehen(float vor, float rechts, float hinter, float links){
if (bewegung != Bewegung.stehen) { //Ausgangszustand nicht vorhanden
return false;
}
if (vor < schwellwert && rechts < schwellwert && hinter < schwellwert && links < schwellwert) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean stehenZuVor(float vor, float hinter){
if (bewegung != Bewegung.stehen) { //Ausgangszustand nicht vorhanden
return false;
}
if (vor > schwellwert && hinter < schwellwert) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean stehenZuZurueck(float vor, float hinter){
if (bewegung != Bewegung.stehen) { //Ausgangszustand nicht vorhanden
return false;
}
if (vor < schwellwert && hinter > schwellwert) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean vorZuStehen(float vor, float rechts, float hinter, float links){
if (bewegung != Bewegung.vor) { //Ausgangszustand nicht vorhanden
return false;
}
if (vor < schwellwert && rechts < schwellwert && hinter < schwellwert && links < schwellwert) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean zurueckZuStehen(float vor, float rechts, float hinter, float links){
if (bewegung != Bewegung.zurueck) { //Ausgangszustand nicht vorhanden
return false;
}
if (vor < schwellwert && rechts < schwellwert && hinter < schwellwert && links < schwellwert) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean vorZuZurueck(float vor, float hinter){
if (bewegung != Bewegung.vor) { //Ausgangszustand nicht vorhanden
return false;
}
if (vor < schwellwert && hinter > schwellwert) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean zurueckZuVor(float vor, float hinter){
if (bewegung != Bewegung.zurueck) { //Ausgangszustand nicht vorhanden
return false;
}
if (vor > schwellwert && hinter < schwellwert) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean vorBleibtVor(float vor, float hinter){
if (bewegung != Bewegung.vor) { //Ausgangszustand nicht vorhanden
return false;
}
if (vor > schwellwert && hinter < schwellwert) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean zurueckBleibtZurueck(float vor, float hinter){
if (bewegung != Bewegung.zurueck) { //Ausgangszustand nicht vorhanden
return false;
}
if (vor < schwellwert && hinter > schwellwert) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}

public static boolean exit(boolean buttonIsPressed){
if(zustand != Zustand.ON){
return false;
}
if (buttonIsPressed) { //Bedingung von Pfeil
return true;
}
return false; //Bedingung gar nicht erfüllt
}


enum Zustand {ON, OFF}
enum Bewegung{vor, zurueck, stehen}
enum Lenkung {links, rechts, geradeaus}
}
[/CODE]

ich habe das problem jetzt versucht mit der Funktion vorwaerts und rueckwaerts zu lösen. Weiß aber nicht ob das funktioniert.

 

[Mart]

öhm wtf

ich habe keinen plan was dein code macht... ich lehn mich mal weit ausm fenster und behaupte eine klasse mit 500 zeilen an code hat die Tendenz vereinfacht zu werden ( meistens kommt die länge von static sachen )

wie wärs statt dem

float vor, float rechts, float hinter, float links

als parameter einen Vektor zu übergeben und die klasse schaut so aus

public class Vektor{
    private float vor;
    private float zurueck;
    private float rechts;
    private float links;
    public Vektor( ... )
        
    // und noch die getter Methoden für die einzelnen werte
    
}

eine methode sollte maximal die länge einer darstellbaren seite haben in deiner IDE dh du sollst nicht scrollen müssen bei einer methode... dh jetzt nich dass du die schriftgröße auf 2 setzen solltest