Druckbare Version
Ja, schau hier: Operatoren nach Priorität geordnetZitat:
Hm-biste da sicher?
Auch ohne Klammern werden die Ergebnisse der Vergleiche verodert.Zitat:
Ich hatte schon nen paarmal damit Probleme...und eigentlich leuchtet es auch ein, da ja jeweils _nur_ die Ergebnisse der Vergleiche verODERT werden müssen.
Danke ihr beiden für eure Tip´s.
ich hab es jetzt so gemacht, das wenn der Sensor Mitte, Vorne Rechts und Rechts ein Hindernis erkennt, stoppt, zurücksetzt sich nach links dreht und dann
wieder gerade aus vor fährt. und natürlich für die Sensoren Vorne Links und Links - nach Rechts ausweichen!
ja Rabenauge, so hab ich mir das mit dem Bumper schon gedacht, deswegen muss ich dann noch zwei Taster integrieren, und natürlich auchCode:void loop()
{
if(tempVORNE_MITTE < triggerDistanz || tempVORNE_RECHTS < triggerDistanz || tempRECHTS < triggerDistanz)
{
zurueck_RECHTS();
}
else
{
vor();
}
if(tempVORNE_LINKS < triggerDistanz || tempLINKS < triggerDistanz)
{
zurueck_LINKS();
}
else
{
vor();
}
}
konstruktiv umsetzten! Recht weit unten angebracht und einfach schwingend aufgehängt wie eine Stoßstange sollte es aussehen! Aber da muss
ich mir dann erst noch ein paar Gedanken machen, einerseits zum Code und andererseits für den Bumper an sich!
Das mit den Tastern kommt ja dann auch in den Loop Teil wo heist wenn Taster HIGH ( z.b.) dann stop - zurück und schauen ob links oder rechts frei
und da wo frei ist hin ausweichen! So hab ich mir das gedacht, nur so geschrieben ist einfacher wie im Code geschrieben :D
Du hast doch nen Mega 2560 drauf. Der hat bei dir aber kaum was zu tun, deshalb würde ich kurzerhand den/die Taster an Interrupts binden.
Das hat Vorteile: die brauchen nie extra abgefragt werden, und es wird immer _sofort_ reagiert.
Hab ich beim Monstertruck auch gemacht: wann immer ich den Joystick-Button drücke (der entkoppelt bei mir auch sämtliche Servos, also auch die Fahrmotoren, bzw. schaltet sie zu (halt an, wenn sie aus sind, und aus wenn sie an sind), wird ein Interrupt ausgelöst der nen Flag setzt (ne simple kleine Variable) die dann _umgehend_ auf das Ereignis reagiert.
Trotz der Tatsache, dass ich nun teilweise wirklich zeitraubende Aktionen am laufen hab, ist da keine merkliche Verzögerung da.
Genau richtig, so als "Notaus".
Wenn man das Ding nämlich nur zyklisch abfragt, kommts drauf an, wann der mal "dran ist"- das kann für nen Notstopp zu lange dauern.
also war der Code richtig wie ich es geschrieben habe?
der Compiler mekert in dem Scan Unterprogramm, das " no match for operator
Das is ja von mir so geschrieben wie es Rabenauge vorgeschlagen hat!
Nur im Original kam im Loop Teil von folgendes: frontDistance = distance;
"distance" ist ja jetzt bei mir "VORNE_MITTE" und tempVORNE_MITTE das hab ich verstanden das die Variable nicht mehr
Golbal sondern Lokal ist!
das mit dem Bumper muss ich schauen, wenn du das so beschreibst wie du das machen würdest, muss ich konzentriert lesen!Code:void scan_VORNE_MITTE()
{
int tempVORNE_MITTE = VORNE_MITTE.ping(); // Variable zum Speichern der Zeit, wie lange das Echo zurück braucht
VORNE_MITTE = tempVORNE_MITTE / US_ROUNDTRIP_CM; // Zeit in Abstand umrechnen
if(VORNE_MITTE == 0)
{ // Wenn kein Echo zurück kommt,
VORNE_MITTE = MAX_DISTANCE; // den Abstand auf Max setzen
}
delay(100);
}
Hab mir damals ein Buch gekauft und hab von Buttons und LEDs und Servos - zu - Xbee und Funkmodulen und Sensoren gewechselt.
Wie ich schon schrieb das ich für sowas halt noch etwas brauche und mich an jedem Projekt steigere.
Machen Ausdrücke sind mir noch fremd, deswegen was für jemand änderst mit dem Bumper Code eine Kleinigkeit ist - für mich immer in Ruhe angehen muss!
Habe gelesen das vor das VORNE_RECHTS wenns Lokal sein soll natürlich auch ein "int" davor muss oder etwa nicht?
In etwa so:
Das heist jetzt sollten die Unterprogramme und die IF Anweisung stimmen, wenn der Code nun steht kann ich mich an die Sensoren an meinem Roboter machen.Code:void scan_VORNE_RECHTS()
{
int tempVORNE_RECHTS = VORNE_RECHTS.ping();
int VORNE_RECHTS = tempVORNE_RECHTS / US_ROUNDTRIP_CM;
if(VORNE_RECHTS == 0)
{
VORNE_RECHTS = MAX_DISTANCE;
}
delay(100);
}
Und denn Bumper mal in Ruhe konstruieren ....
Sieht relativ gut aus aber:
int VORNE_RECHTS solltest du wohl schon global lassen-auf diesen Wert willst du ja an anderer Stelle auch zugreifen dann?
Für sowas benutz ich immer die serielle Konsole-da kann man fix mal ne Ausgabe schreiben, und gucken, ob dieser oder jener Wert auch dort ankommt, wo er gebraucht wird.
okay, da hast du auch wieder recht sollte schon global belieben.
Und dann mal zum Testen kann ich den Code für den Taster schon mal normal schreiben oder also so das auch ich ihn verstehe :D
Kannst du aber machs mit Interrupts. so eine Sicherheitsfunktion ist recht nutzlos, wenn sie erst nach Sekunden reagiert...
Ja, das is natürlich Sinnvoll, ich will es ja nicht nur als Sicherheitsfunktion, sondern ich hab in der Wiese Steine wo die Ultraschall Sensoren nicht erkennen und im Garten ein kleines
Stückchen mit so Holzrabatten begrenzt, das erkennen die Sensoren auch nicht!
Sprich der Bumper soll auch dazu dienen, wie besagt, stoppen, zurücksetzten, wenden und weiter gerade aus!
Nur das mit den Interrupts muss ich mir noch sehr genau anschauen!
Was mich auch noch brennend interessiert ! Wie ich das umsetzte das wenn es heist fahre gerade aus das der Roboter auch gerade aus fährt!
Also mit einem Giro Kreisel oder so und dann Sensoren an jedem der beiden Motoren, das die Software auch weis was der Roboter macht!
Sprich, wenn man vorn gegen den Roboter drück, wenn er gerade aus fährt oder das Gelände uneben ist! Das er selbständig koregiert und
wahrscheinlich mit Toleranz versehen die Spur automatisch hält!
Aber wollen wir es nicht gleich übertreiben, Stück für Stück, das ist ja ein Hobby und kein Projekt was morgen fertig werden muss!
Hab jetzt erstmal die Halterungen für die Sensoren konstruiert, werden dann am Wochenende programmiert, muss mir nur noch
über die Kabelführung Gedanken machen ..... wie immer wenn Bilder gewünscht sind einfach sagen^^
Mach ruhig ab und zu Bilder-warum nicht.
Eine Geradeausfahr-Regelung willst du also einbauen, hm...am simpelsten würde das in deinem Fall (mit deiner abenteuerlichen Ansteuerung als Servos) wohl mit nem ganz normalen Modellbaukreisel gehn. Da brauchst du überhaupt nix in Software zu machen-aber:
Das ist doch nicht das Ende der Fahnenstange. Schliesslich willst du irgendwann ja auch effektiv mähen können-derzeit ist der Stand so, dass das Teil eher willkürlich auf der Wiese rumfahren wird, und dabei-zufällig- alles mäht irgendwann, oder auch nicht.
Da wäre ein Kompass natürlich sinnvoller (war nicht auch mal ein GPS im Gespräch?-die liefern ohne richtigen Kompass nicht allzu oft ordentliche Kursdaten, also wär der auch dafür sinnvoll).
Aber: der sollte etwas weg von jeglichem (wirklich: jeglichem) Eisen sein, und falls deine Einsatzwiese nicht tischeben ist, braucht er ne Neigungskompensation. In Schräglage misst er nämlich sonst Mist.
sowas tüdele ich grad auch an den Monstertruck: HMC 5883l als Kompass (spottbillig beim Chinesen, hab 1.5o oder so gezahlt) und dazu die MPU 6050 als Neigungsmesser. Damit kann man den Kompass mit einer Kompensation versehen-ich hoffe jedenfalls, ich kriegs hin.
Gibts aber auch als komplette Module, die heissen dann 9050 oder so (9DoF), haben Kompass, Beschleunigungsmesser und Gyroskop drauf. So ein Ding kann deine Geradeausfahr-Regelung quasi nebenbei mit erledigen.
Da die im allgemeinen per I2C ausgelesen werden, sind auch Pins kein Problem...
Klar CAD Bilder kann ich am Wochenende mal einstellen. Bin gerade dabei mir Gedanken zur Umsetzung, der Haltungen für Sensoren zu machen, Aussehn, Funktion, Kabelführung
Befestigung und Design usw usw.
Das mit der Navigation, is für mich noch bisschen Bahnhof, aber ich arbeite mich dann schon ein - wie ich geschrieben hab - eins nach dem anderen. Ist ja ein Hobby und nichts was morgen fertig sein muss!
Weis dann natürlich noch nicht ob ich lieber einzelne oder ganze Module verwende - wie gesagt - davon hab ich nun wirklich keinerlei Erfahrung.
Gut anhören tut sich das schon mal, währe natürlich auch bombastisch wenn der Roboter wüsste wo er schon gemäht hat! Ist ja bestimmt auch machbar - mit dem nötigen Wissen natürlich =)
Den nächsten schritt was ich machen will is das mit den Ultraschall Sensoren und deren Halterung das dass zuverlässig funktioniert - natürlich mit dem wissen das er willkürlich auf der Wiese
um her fährt! Anschließend dann die Bumper und dann schauen wir weiter =)
Bei einem "festen Arbeitsplatz" ist das gar nicht mal soo schwer: du kannst ihm einfach Kurse programmieren (ähnlich wie ich es mit dem Monstertruck vor habe, der bekommt auch Routen, bestehend aus mehreren GPS-Punkten, und soll sich dann an denen lang von A nach B hangeln), musst halt nur für sorgen, dass er auch seine aktuelle Position immer genau genug weiss-mehr als ne halbe Mäherbreite Abweichung sollts nicht werden. Bei deinem, recht langsamen Maschinchen, halte ichs für machbar- nen ordentliches GPS schafft Genauigkeiten unter nem Meter inzwischen.
Wenn du den natürlich auf verschiedenen Wiesen (auch vorher nicht bekannten...) einsetzen willst, muss er das alles selber erledigen-dann wirds herausfordernd.
Ich speichere meine Routen einfach auf ner SD-Karte, da kann ich hunderte raufpacken, und dann unterwegs einfach die gewünschte wählen.
Ganz soweit bin ich allerdings noch nicht, und wenn, dann schaun wir mal, wie weit ich das noch aufbohren will (da geht noch so richtig viel mehr).
Für deinen Mäher: hast du nicht eh ne Fernsteuerung dran?
Dann kannst du doch recht "sorglos" testen- solltest das Gerät natürlich im Auge behalten, und dir die Fernsteuerung als "Notaus" programmieren.
So kannst du ganz gemütlich deine Hinderniserkennung testen- und hast hinterher auch noch ne gemähte Wiese.;)
ja das weis ich auch noch nicht so ganz, bis jetzt hab ich zwei so genante Arbeitsplätze ... also zwei Wiesen!
Ich weis aber nicht ob ich nicht doch mal wo anderst mähen muss!
ja ich denke mit GPS kann man ein paar schöne Dinge anstellen, momentan sind mir aber die Sensoren völlig ausreichend!
Wie du schon erwähnt hast, das GPS immer genauer wird. Wir wollen ja nicht gleich übertreiben!
Ich bin immer noch daran an denn Interrupts zu schauen, wenn ich richtig verstanden habe! wenn ich es so schreibe unter die Anweisungen der Ultraschallsensoren
Dann würde der Bumper nicht gleich funktionieren weil die Abfrage nicht gleich erfolgt sondern irgendwo in der Reihenfolge fest steckt!Code:bumperStatus_RECHTS = digitalRead(bumperPin_RECHTS);
if(bumperStatus_RECHTS == HIGH);
{
zurueck_LINKS();
}
if(bumperStatus_RECHTS == LOW);
{
vor();
}
// -----
bumperStatus_LINKS = digitalRead(bumperPin_LINKS);
if(bumperStatus_LINKS == HIGH);
{
zurueck_RECHTS();
}
if(bumperStatus_LINKS == LOW);
{
vor();
}
}
Dafür die Interupts das egal an welcher Stelle der Code gerade steckt, das wenn der bumper gedrückt wird, der Roboter reagiert!
Hab ich das richtig verstanden ?
Ja ich hab nen Arduino Uno als Sender wo ein Joystick dran hängt ein Uno der mit dem Mega zusammen im Roboter steckt!
Funkverbindung wird ausgeführt mit Hilfe zweier NRF24L01+ Modulen wobei nochmals ein Großer Dank an Sisor geht "Daumen Hoch"
Das ist so zu sagen ein eigener Kreislauf, wenn ich mit dem Autonomen mähen fertig bin und noch hier und da ein Gras Büschel steht oder ein kleines Eck vergessen hat,
bzw nicht erreicht hat, steuere ich ihn von Hand bzw manuell wenn man es so nennen mag, hin und mähe das von Hand weg, genau so um Bäume oder Büsche herum,
das mähe ich auch vorher manuell und wenn ich das hab, schalte ich die Fernsteuerung und den UNO im Roboter aus und den Mega an und es geht Autonom weiter .....
Ja-im Groben hast du es richtig verstanden. Ein Interrupt unterbricht das laufende Programm sofort (genauer gesagt, nachdem der aktuelle Maschinenbefehl abgearbeitet ist), und es wird eine sogenannte ISR (praktisch nen eigenes Unterprogramm) aufgerufen. In der kann man nun _irgendwas_ wichtiges veranlassen.
Das geht im allgemeinen weit schneller, da ansonsten deine Bumper nur dann abgefragt werden, wenn die eben dran sind.
Wozu du allerdings für das bisschen Fernsteuerung nun noch nen Uno brauchst...kann der Mega doch auch noch mit erledigen...
ja okay dann hab ich schonmal das richtig verstanden^^
Werde noch schauen - wie ich das Lösen kann.
Ganz einfach weil das mein erstes Arduino Projekt war bzw so mit das erste! klar könnte das der Mega mit erledigen, aber die beiden Unos sollen die Fernsteuerung übernehmen!
Und der Mega alles alles andere was noch kommen soll, mit Sensoren, Autonom und Roboter Arm usw usw!
Wenn ich dann mal die erforderliche Erfahrung auf bringen kann, werd ich vllt alles über den Mega machen und nur noch der Uno in der Fernsteuerung!
- - - Aktualisiert - - -
Hab mal zwei Fragen zu den Interrupts:
Habe ein gutes Tutorial gefunden nur beschreibt derjenige meine Frage nicht!
Mega2560:
Inter. 0 = Digitaler Pin 2
Inter. 1 = Digitaler Pin 3
Inter. 2 = Digitaler Pin 21
Inter. 3 = Digitaler Pin 20
Inter. 4 = Digitaler Pin 19
Inter. 5 = Digitaler Pin 18
Er beschreibt hier die INTER Liste - heist das ich kann die Bumper nur an die Pins anschließen wo dafür vorgesehen sind ?
Und würde das mit den Interrupts im Setup teil dann so aussehn?
Denn er schrieb im Tutorial: “attachInterrupt(INTER, FUNKTION, MODUS)”Code:attachInterrupt(2, zurueck_RECHTS, RISING);
attachInterrupt(3, zurueck_LINKS, RISING);
Also 2 für den Inter / zurück_RECHTS für die Funktion und Modus "RISING"
Das steht für : Löst aus wenn der Wert des Pins von LOW auf HIGH wechselt
Aber wenn das so passt müsste es das im Setup Teil gewesen sein oder ? also natürlich noch die Globale Variable für den Interrupt deklariert,
und dann natürlich das aus dem vorherigen Post heraus löschen - das is ja klar!
Und trotzdem das man es in den Setup Teil des Sketches schreibt, löst es dann die Funktion aus die beschrieben ist? Weil ich gedacht habe das was man im Setup Teil schreibt
wirklich nur einmal gelesen bzw abgearbeitet wird! Als Info der Compiler meckert schonmal nicht - Grins^^
Interrupts müssen nur einmal "initialisiert" werden-weiter nix. Ist das gemacht (so wie du es beschreibst), löst jedes Ereignis (RISING) den Interrupt aus und es wird der Handler aufgerufen.
ABER: ich würde auf gar keinen Fall zwei Interrupts verschwenden dafür. Du kannst beide Schalter auf einen legen, dann isses Wurst, welcher anspricht. Das spart nicht nur nen Interrupt (einige Bibliotheken benötigen auch welche!) sondern du gehst auch sicher, dass die beiden Interrupt-Handler sich nicht gegenseitig in die Quere kommen, denn das musst du in jedem Fall ausschliessen.
Im Interrupt-Handler würde ich deshalb auch nur zwei Dinge tun:
1. das Fahrwerk sofort stoppen
2. ein Flag setzen. Dieses wird dann im normalen Programmablauf ausgewertet, und es können Rangiermanöver oder ähnliches folgen.
Zudem kann man den Interrupt, wenn er einmal ausgelöst wurde, noch für eine gewisse Zeit "verriegeln". Es muss sichergestellt sein, dass der Interrupt-Handler nicht mehrmals zugleich aufgerufen werden kann. und: nen Taster würde ich immer entprellen, das ist somit gleich mit erledigt.
Beim Monstertruck sieht der Interrupt-Handler so aus, mit Entprellung:
und initialisiert wird der Interrupt so:Code:void buttonHandler()//*******************ISR für den Joystick-Button, entprellt*********************
{
static unsigned long lastInterruptTime = 0;
unsigned long interruptTime = millis();
if (interruptTime - lastInterruptTime > 200)
{
if(servoMode==0)
{servoMode=1;}
else
{servoMode=0;}
}
lastInterruptTime = interruptTime;
}
attachInterrupt(1,buttonHandler,RISING); // Interrupt für den Stickbutton in der setup()
Beachte dass man die Interupt-Nummer angeben muss, _nicht_ den Pin! Das ist in meinem Fall Pin 3.
Achja: ich hab den Pin auf INPUT_PULLUP gestellt, anders hats nicht funktioniert. Kommt aber drauf an, wie das genau verschalten ist (ich glaub, mein Button gibt beim Drücken LOW aus).
Und: ich kann mit dem Interupt sowohl die Antriebe ein-als auch aus schalten, da ich ne Abschalt-Automatik drin habe, die den Antrieb nach einer bestimmten Zeit anhält. So kann ich den mit dem Button auch wieder aktivieren.
hmm okay, und wieso keine zwei Interrupts? der Mega hat ja genug Speicher oder des gleichen! Ist es dann nur das die beiden Interrupts sich nicht in die Quere kommen?
Denn dann verstehe ich auch nicht wie ich die beiden Schalter / Taster anschließen soll - ich brauch ja für jeden Taster ein Pin am Mega! Weil wenn ich ihn an Pin 21 anschließe,
heist der Inter ja 2 so wie hier: attachInterrupt(2, zurueck_RECHTS, RISING);
Dann fängts schon wieder an, dein Beitrag kann ich verstehn aber am Code tu ich mir wieder schwer >.<
Wobei es ja auch Englisch ist und nicht Deutsch wie du letzt geschrieben hast^^;-)
Was mir auch schleierhaft ist der " Servo Mode" also wo sag ich ihm was er machen soll im viid buttonHandler .....
Also in meinem Falle " zurück_RECHTS oder zurück_LINKS ....
Wollte auch zwei haben, das wenn der rechte gedrückt wird, nach links ausweicht und wenn der linke Interrupt ausgelöst wird,
nach rechts ausweicht! Wie kann ich das nun in deinem viid buttonhandler lösen?
Aber ich sollte es dann schon so machen wie du es vorgeschlagen hast? Alleine schon wegen dem Entprellen .... oder ?
Du hast unter anderem zwei "Servos" laufen (für den Mega sind die Fahrtregler nix anderes)- vermutlich über die Servobibliothek?
Die braucht mindestens einen Interrupt schon mal. Diverse andere Bibliotheken ebenfalls (ich glaub, auch NewPing nutzt einen)-man gehe also sparsam damit um, sonst könnte was anderes nicht mehr funktionieren. Mein Monster z.B. kann tone() nicht mehr benutzen-auch das bräuchte nen Interrupt-und alle sechs sind belegt!
Ausserdem darf eine ISR niemals unterbrochen werden (dort wird ja das laufende Programm angehalten, und wenn nun die ISR selber gestoppt würde, weil noch ein Interrupt kommt, kannste dir denken, dass sich das Programm nie mehr in das Hauptprogramm zurückfindet). Aber genau das würde passieren, wenn die beiden Taster "zugleich" ausgelöst werden. In Wirklichkeit werden sie das nämlich nie-sondern mindestens um Mikrosekunden versetzt.
Und: wozu auch? Häng die beiden Taster parallel an einen Pin, dann isses Wurst, welcher der beiden, oder ob beide auslösen. Einfacher gehts gar nicht...
Zur ServoMode: das läuft bei mir so, dass es ne Variable gibt (quasi nur ein Flag) die so heisst. Im Hauptprogramm (eigentlich auch nur in nem Unterprogramm, weil das Hauptprogramm bei mir nur die jeweiligen Fahrprogramme startet) wird zyklisch ein Unterprogramm aufgerufen, was den deutlichen Namen schalteServosAnAus() trägt.
Das guckt, ob ServoMode 1 hat oder 0 und wenn 0, werden die "Servos" (der Fahrtregler ist aus Arduinosicht auch nur ein Servo) abgeschalten, und bei 1 wieder an.
Ist noch bisschen komplizierter, weil das in Wirklichkeit nur dann passiert, wenn sich der Modus auch geändert hat, aber im Prinzip eben.
Das musste ich so machen, weil man natürlich aus der ISR raus nicht noch nen anderes Unterprogramm aufrufen kann bzw. sollte.
Im Prinzip kannst du das genauso machen, dann gehst du sicher, dass eine Betätigung der Stostange niemals verpasst wird, und hast dennoch ne akzeptabel schnelle ISR.
Den Teil:
if(servoMode==0)
{servoMode=1;} kannst du rauslassen (bzw. solltest du...) da der meine Antriebe dann einschaltet, wenn sie bereits aus sind.
Der Rest ist die Entprellung, hier wird sichergestellt, dass nur alle 200ms der Interrupt auch "registriert" wird, das musste ich einbauen, da ich eben ein-und ausschalten kann damit.
Hier dazu noch das Servo-Schalt-Unterprogramm:
Das wird einfach in den meisten Fahrprogrammen immer mit in die Schleife genommen, und wenn sich der Servomodus zwischendurch geändert hat (und _nur dann_), tut es seinen Job. Vorteil: es kann auch ohne den Interrupt arbeiten, weil man im Programm die Variable servoMode jederzeit ändern kann. Bei mir ist da z.B. noch ein "Timer" programmiert, der momentan nach ner Minute Fahrzeit die Servos abschaltet- damit mir das Monster nich abhauen kann. Es stoppt also nach dieser Zeit _immer_ - ich gehe hin, drücke den Button, und weiter gehts. Die Zeitspanne kann ich natürlich beliebig verändern, später (wenn ich sicher bin, dass nix mehr schiefgeht) kann das ganz raus.Code:void schalteServosAnAus() //********** Servo und Regler zu-oder abschalten *******************
{
if (servoModeAlt!=servoMode)
{
switch(servoMode)
{
case 1:
fahrtRegler.attach(PIN_FAHRTREGLER); // Fahrtregler
lenkServo.attach(PIN_LENKSERVO); //Lenkservo
break;
case 0:
fahrtRegler.writeMicroseconds(1500);
delay(100);
fahrtRegler.detach();
lenkServo.writeMicroseconds(geradeAus);
delay(100);
lenkServo.detach();
break;
}
servoModeAlt=servoMode;
}
}
Auch, wenn z.B. der Fahrauftrag erledigt wurde, wird servoMode auf 0 gesetzt, um dann anzuhalten, oder wenn die Akkuspannung zu niedrig wird...genauso wird per Software eingeschalten im Fahrmodus GPS2Home, wenn die Kursdaten berechnet sind und das GPS einsatzbereit ist. Ist also schön flexibel.
oookay, jetzt wird's wieder zu viel^^vllt denk ich manchmal auch zu kompliziert das kann ich mir schon vorstellen!
Also Fakt ist 1x Interrupt und die beiden Taster Parallel an ein Mega Pin ?
Wie gesagt was ich dann noch ned verstanden hab! Ich wollt ja wenn der eine Taster gedrückt wird soll er in die eine Richtung ausweichen
und wenn der andere Taster gedrückt wird soll er in die andere Richtung ausweichen!
Das kann doch parallel geschaltet ned funktionieren oder ?
Ja klar ich benutz ide Servo.h der Fahrtenregler ist nichts anderes wie zwei Servos, das ist bei mir nichts anderes wie bei dir!
Bin mit den beiden Codes die du jetzt beschrieben hast etwas verwirrt ... der zweite war nur zur demo oder?
mein Hauptprogramm sieht wie folgt aus!
Also wirklich recht einfach weil wie gesagt das komplizerte noch nicht geht!Code:void loop()
{
if(tempVORNE_MITTE < triggerDistanz || tempVORNE_RECHTS < triggerDistanz || tempRECHTS < triggerDistanz)
{
zurueck_LINKS();
}
else
{
vor();
}
if(tempVORNE_LINKS < triggerDistanz || tempLINKS < triggerDistanz)
{
zurueck_RECHTS();
}
else
{
vor();
}
}
Ich hab auch einzelne Fahrprogramme wie vor() / zurück_RECHTS() / stop() usw
Ich verstehe jetzt grad nicht, das wenn ich ein Interrupt habe und zwei Taster, denen zu sagen wenn ausgelöst dann mach dies!
Hab ich ja versucht mit Hilfe von :
Aber glaub das mit dem ServoMode hab ich nicht ganz verstanden, also wie du es gemeint bzw beschrieben hast schon, aber wie ich es dann für meinCode:attachInterrupt(2, zurueck_RECHTS, RISING);
Programm umsetzen kann - O.o ( Bitte Geduld mit mir :-))
- - - Aktualisiert - - -
Ich könnte es doch so machen, ein Interrupt mit den beiden Tastern.
Das wenn der Interrupt ausgelöst wird, das der Roboter zurück setzt und dann nochmals mit Hilfe von den US Sensoren prüft
ob links oder rechts vom Roboter etwas ist und dann da hin ausweicht wo nichts ist und wenn auf beiden Seiten nichts ist,
soll er immer nach rechts ausweichen ... z.B.
Du hast alles in der Hauptschleife- das hab ich mir abgewöhnt. Kann man, bei einfacheren Programmen, natürlich tun aber:
-ich hab verschiedene Fahrmodi (im Grunde alles eigene Programme, von denen eins beim einschalten ausgewählt wird), und jedes dieser Programme benutzt ne andere Konfiguration (im manuellen Fahrprogramm, bei dem das Auto per Joystick bedient wird, brauche ich weder GPS noch die anderen Sensoren, im Modus "nur Hinderniserkennung" brauche ich den Joystick nicht, ebensowenig GPS und Kompass, usw).
Daher bot es sich an, so ziemlich alles in einzelne Unterprogramme zu packen, die ich, je nach Notwendigkeit, eben aufrufe -oder auch nicht.
Ich kann dir nicht sagen, wieviele einzelne Tasks momentan im Programm sind, aber bestimmt mehr als ein Dutzend (Display, Servosteuerung, 4x Sensoren, Interrupthandler, Kursberechnung, GPS, Kompass und Kompassdaten-Aufbereitung,SD-Karte befragen oder beschreiben........)- aber so halbwegs hab ich immer noch den Überblick, weil die einzelnen Unterprogramme recht überschaubar bleiben.
Meine loop() ist relativ kurz, da die nicht viel erledigt.
Und nein: du kannst mit zwei parallel geschaltenen Tastern natürlich nicht mehr rausfinden, welcher nun betätigt wurde- ich dachte, dafür hast du die US-Sensoren, und die Taster sollen ne Art Notstopp werden??
Bei einem Notstopp isses erstmal Wurst-da kommts drauf an, dass die Kiste _sofort_ stoppt-alles andere kann man dann in Ruhe erledigen, meinste nich?
Ich würde, bei nem Rotationsmäher, den Notstopp so auslegen dass, wenn er ausgelöst wird:
-das Fahrwerk unverzüglich stoppt
-der Mäher selber sofort bis auf den Boden abgesenkt wird (sicherlich auch nicht optimal, aber an nem solchen Mäher kann man keine Bremse verbauen, da fliegt das Messer weg)
-und nun würd ich rausfinden, was eigentlich los war.
Alles andere ist hier zweitrangig...
Falls du wirklich mit zwei Interrupts arbeiten willst (ich würd das nicht machen, siehe oben, aber ist dein Ding), solltest du in der jeweiligen ISR zuerst alle Interrupts mal sperren (weiss ich im Moment nicht ausm Kopf, wie das geht, aber mit detachInterrupt() oder so ähnlich sollt das machbar sein) und am Ende der ISR dann wieder freigeben.
Den Teil der Servo-Ein-oder Ausschalterei könntest du im Prinzip direkt übernehmen, du hast zwei "Servos" dran, wenn ichs noch richtig weiss, ich auch. Mein drittes (der Hecksensor) wird dabei ja nicht berücksichtigt, der hat mit der Fahrerei nix zu tun.
Weiss nicht, wie du deine "Servos" ansteuerst, ich mache das nie mit Gradangaben, da kommt dauernd Murks heraus, und die Einstellungen bei writeMicroseconds() musst du natürlich ggf. ändern-die passen zu meiner Lenkung und meinem Fahrtregler.
Die hab ich im Kopf mittels #define geradeaus 1500 (bzw. eben die richtigen Werte) global festgelegt.
Du bräuchtest dann lediglich in deiner Programmschlaife immer wieder schalteServosAnAus() mit aufrufen, und wenn sich der servoMode mal geändert hat, reagiert das Unterprogramm-ansonsten tut es einfach gar nix.
ja so wie du sehe ich das auch, das bei einem Notstop erstmal alle steht, nur wollte ich dann gleich mit entscheiden, das wenns wieder weiter geht, ob er nach rechts oder Links weiter fährt!
Deswegen die beiden Taster. Ich würde jetzt halt mal so machen, das ich mal die beiden Interrupts ausprobiere, ist ja auch so das ich erstmal die 5 Sensoren am Roboter anbringen muss!
Ich weis ja noch garnicht ob mein Sketch geht oder nicht? Deswegen würde ich erstmal die beiden Interrupts lassen.
Denn muss mich ja naoch Gedanken machen wie ich das mit dem Bumper umsetze!
Mein loop Teil ist auch recht kurz! der ganze Code recht lang, das mit den Task hab ich auch schon gesehen, weis ich aber nicht wie das geht!
Dann könnte ich den Sketch bisschen übersichtlicher machen! Dann währe er nicht so lang! Und ich könnte alles in die Einzelnen Tasks unterteilen!
Jetzt würd ich gerne erstmal Stück für Stück machen und ned den ganzen Code gleich fertig schreiben! Weil sonst weis ich ja ned wenn was ned geht woran es hebt!
Habe noch eine Woche Urlaub, da will ich auf jeden Fall die Sensor Abdeckungen fräsen und die Große Sensor Halterung .... vllt klappt es noch das ich nachher Bilder vom
fertig konstruierten einstelle!
Aber das mit den Tasks währe schon mal ne große Hilfe zu wissen wie es das geht!
Und Danke an die Rabenauge, das du mir das immer so Ausführlich erklärst - finde ich große Spitze :-)
noInterrupts()Zitat:
Zitat von Rabenauge
Könnte mir falls das jemand macht oder weis wie man mit den Tabs umgeht im Ardiono pde ?
Das ich zb die Fahrtprogramme nicht im gleichen Fenster habe wie der Loop oder Setup Teil?
Das ich das ein wenig übersichtlicher gestalten kann. Oder macht man das in der Regel nicht so?
Wisst ihr was ich meine ?
Da gabs schon mal nen Thread zu: TabsZitat:
Könnte mir falls das jemand macht oder weis wie man mit den Tabs umgeht im Ardiono pde ?
Danke Sisor, würdest du / ihr das so machen oder habt ihr das alles in einem Tab?
So dann hier mal die Bilder, wie ich mir das mal so vorstelle ..... Ist noch nicht ganz fertig aber das ihr mal wisst wie ich mir das vorstelle!
Hier zwei Bilder von der Sensor Abdeckung die für die Ultraschallsensoren sind!
Werden gefräst aus dem Vollen, also sprich aus einem Stück Rennsport-ALuminium.
Die wo zu kaufen sind gefallen mir nicht und ich will das nicht so haben, so wie ich es
mit den einfachen Halterungen machen müsste, ich will z.b. die Kabel nicht sehen möchte dazu im dritten Bild mehr!
Anhang 28917Anhang 28918
Hier nun das Bild von der Halterung die dann Schwinungsfrei am Roboter montiert wird!
Die Halterung wird auch komplett aus einem Stück Aluminium gefräst!
Hier seht ihr die Freimachung unter der Abdeckung zur Kabelführung! Wie schon gesagt das ich die nicht sehen möchte!
Anhang 28919
Im Gesamten sieht das dann wie folgt aus, die Höhe bis zum Boden bzw Rasen wird so 30 bis 35cm liegen!
Je nach dem wie sehr der Roboter im Rasen einsinkt! auf der Hälfte sollen dann die Stoßstange so zu sagen zum Schutz
mit dem Notstop Programm befestigt werden! Die Sensor Halterung ( GRÜN ) ist schon fertig das Design der Kompletten Sensor
Halterung ist noch nicht ganz fertig - werd euch dann das Finale Design nicht vorenthalten werde!
Anhang 28920
Als Nachtrag:
Auf Bild zwei .... Stehen die Pins des HC-SR04 nach unten, das kommt daher weil ich es erst anderst machen wollte, habe es
noch nicht umkonstruiert! Die Pin´s müssen natürlich gernade schauen das der Stecker dann auch drauf passt.
Bei größeren Programmen ist eine Modularisierung immer sinnvoll. Also je ein Tab für die Funktionen und Variablen aus Funk, Motorsteuerung, Sensorabfrage etc. macht schon Sinn. Das Hauptprogramm sollte dann nur noch initialisieren (setup) und die abstrakte (grobe) Abarbeitung darstellen (loop).Zitat:
Zitat von Benny1989
okay dann werd ich das mal probieren so zu machen - meld mich wenn ich evtll noch die eine oder andere frage habe!
Müssen die Variablen auch mit in die anderen Tabs oder können die im Main bleiben ?
Wenn du globale Variablen meist: Kommt drauf an.Zitat:
Müssen die Variablen auch mit in die anderen Tabs oder können die im Main bleiben ?
Das hier z.B. funktioniert:
Code:// main
int globaleVariable = 10;
void setup() {}
void loop() {
tuwas();
}
----------------------------------Code:// tab
int tuwas() {
return globaleVariable;
}
Das hier NICHT:
Code:// main
void setup() {}
void loop() {
tuwas();
globaleVariable++;
}
----------------------------------Code:// tab
int globaleVariable = 10;
int tuwas() {
return globaleVariable;
}
so klappts trotzdem:
Code:// main
extern int globaleVariable; // Compiler die andernorts definierte Variable mitteilen
void setup() {}
void loop() {
tuwas();
globaleVariable++;
}
Code:// tab
int globaleVariable = 10;
int tuwas() {
return globaleVariable;
}
also ist "return" der springende Punkt?
im Main steht:
int tempVORNE_MITTE; oder
int ledPin_ROT = 4; oder
int bumperPin = 6;
in dann hab ich es in verschiedene Tabs aufgeteilt wie du ja shon richtig geschrieben hast!
und in dem tab muss dann vor die globale variable das "return" davor?
also anhand von einem Beispiel nur das ich es versteh und wir nicht aneinander vorbei reden!
das is der Main Teil
und das in neuem Tab der heist Ampel.pde (pde zeigt es dann nicht an in dem Tab )Code:int ledPin_ROT = 1;
int ledPin_ORANGE = 2;
int ledPin_GRUEN = 3;
void setup()
{
pinMode(ledPin_ROT, OUTPUT);
pinMode(ledPin_ORANGE, OUTPUT);
pinMode(ledPin_GRUEN, OUTPUT);
ampel();
}
void loop()
{
}
int ledPin_ROT = 4; zählt ja auch als globale variable - Richtig?Code:void ampel()
{
digitalWrite(ledPin_ROT, HIGH);
delay(10000);
digitalWrite(ledPin_ROT, LOW);
digitalWrite(ledPin_ORANGE, HIGH);
delay(5000);
digitalWrite(ledPin_ORANGE, LOW);
digitalWrite(ledPin_GRUEN, HIGH);
}
Der Compiler meckert so aber nicht!
Nein, das hat nichts miteinander zu tun.Zitat:
und in dem tab muss dann vor die globale variable das "return" davor?
Hab meine Erklärung oben ergänzt.
Okay ja das hab ich verstanden!
Aber ist mein Beispiel mit der Ampel richtig? also das man dann gewisse Teile so in Tabs einfach schreiben kann?
Weil wie gesagt mit dem Bsp bei der Ampel er nicht meckert
Klar, das Ampel Beispiel ist ok.
Ich würde aber alternativ
#define LEDPIN_ROT 1
#define LEDPIN_ORANGE 2
#define LEDPIN_GRUEN 3
(Großbuchstaben) empfehlen, weil es sich hier um Konstanten handelt. Kein Muss, aber guter Stil.
Okay, Konstanten das Wort hat mir gefehlt ....
also LED oder Button Pins sind Konstanten! und Das andere Variablen - Global oder Lokal.
Ich wollte e schon Fragen, was zwischen den beiden Unterschiedlichen Schreibweisen der unterschied ist!??
int LEDPIN_ROT = 1; und #define LEDPIN_ROT 1
ich hab schon bemerkt immer wenn eine Library im Spiel ist also, NEW PING.h oder Servo.h wird das gerne gemacht!
Hat das einen bestimmten Grund oder einen bestimmten Vorteil?
Wobei es ja auch: int LEDPIN_ROT und const int LEDPIN_ROT gibt also wenn die Konstante nicht geändert werden soll.
Wie macht man das dann mit dem #define wenn man sie nicht ändern darf oder ist das schon von Anfang an gegeben?
'Nerdmütze aufsetzen'
#define ist eine Präprozessor-Direktive (wie alle Befehle, die mit '#' beginnen). Bevor der Kompiler den Quelltext in Maschinencode übersetzt, ist der Präprozessor am Start. Der 'klebt' zuerst alle Quelltextteile zusammen, sofern mit #include andere Teile integriert werden sollen. Also bastelt erstmal einen Gesamtquelltext. Gleichzeitig werden auch alle '#define-Begriffe', die im Quelltext vorkommen ersetzt. Also z.B. wo LEDPIN_ROT steht, wird dies mit einer 1 ersetzt.
'const int' arbeitet anders, weil noch eine Typenprüfung stattfindet. Also z.B. würde 'const int zahl = 17.44;' eine Fehlermeldung provozieren, weil hier eine Gleitkommazahl als Ganzzahl definiert werden soll. Normalerweise sollte z.B. 'const int zahl = 8;' vom Optimierer des Kompilers ebenso direkt in Maschinencode geschrieben werden, so dass effektiv außer der Typprüfung kein Unterschied zwischen beiden Schreibweisen vorhanden ist.
'Nerdmütze wieder absetzen'
Kurz: Beide Definitionen sind sich sehr ähnlich.
grins okay - danke für die Erklärung
Also wie man es praktisch schreiben möchte, manchmal braucht man aber ja const int.
Habs grade am mega Getestet mit dem AmpelCode, funktioniert mit den Tabs einwandfrei^^
@ Sisor eine Frage, du hast doch mit bekommen, das ich meine 5 Sensoren mit der oder Abfrage, abfrage.
Wenn das alles verodert ist fragt er dann auch einen nach dem anderen ab? Nicht das ich mir mit den Echos in die Quere komme ???Code:void loop()
{
if(tempVORNE_MITTE < triggerDistanz || tempVORNE_RECHTS < triggerDistanz || tempRECHTS < triggerDistanz)
{
zurueck_LINKS();
}
else
{
vor();
}
if(tempVORNE_LINKS < triggerDistanz || tempLINKS < triggerDistanz)
{
zurueck_RECHTS();
}
else
{
vor();
}
}
Also ned das der eine Sensor das Echo vom anderen Sensor abfragt!
Ich sehe in deinem Quelltext überhaupt keine Abfrage der Ultraschall-Sensoren.
ja grins ....
weil die in den Unterprogrammen stecken^^
Code:void scan_VORNE_RECHTS()
{
int tempVORNE_RECHTS = VORNE_RECHTS.ping();
int VORNE_RECHTS = tempVORNE_RECHTS / US_ROUNDTRIP_CM;
if(VORNE_RECHTS == 0)
{
VORNE_RECHTS = MAX_DISTANCE;
}
delay(100);
}
- Deine Funktion ist vom Typ void, liefert also keinen Wert zurück.
- Dein Hauptprogramm ruft diese Funktion nie auf.
em stimmt, so klappt das wahrscheinlich nicht
ja aber welche Funktion sollte es sonst sein? muss dann eine sein wo auch zurück gibt, hab aber auch gedacht das
void zurück gib .... :-(
währe das dann z.b. " char" ??
-void bedeutet Leere, Nichts.
-wozu das delay?
-warum nicht einfach
Damit kannst du dir die Funktionen sparen.Code:void loop()
{
int vm = VORNE_MITTE.ping_cm();
int vr = VORNE_RECHTS.ping_cm();
if(vm && vm < triggerDistanz || vr && vr < triggerDistanz ...
}
Um deine ursprüngliche Frage zu beantworten: Die US_Sensoren werden nacheinander abgefragt, und kommen sich nicht ins Gehege.
Übrigens: Bei 70cm maximaler Distanz dauert ein ping-Funktionsaufruf etwa 2*0,7/340 s = 4 ms lang.
okay also so kann ich das auch machen, mit der separaten Funktion hab ich es halt etwas besser verstanden !
Das heist ein US Sensor brauch 4ms für eine Messung?
Ich glaub dir schon das dass so ist hab ich ja auch grad gelesen....
Nur hab ich schon Beispiel Programme gesehen, wo die das auch mit "void" gemacht haben - komisch
Ich hab zum Beispiel global Deklariert die Distanz und die Maximale Distanz:
Brauch ich das halt dann noch trotzdem ?Code:int triggerDistanz = 70;
int MAX_DISTANCE = 100;
Weil ich würd gern vorerst das so mit den Unterprogrammen machen! Weil das es für mich verständlich bleibt!
Du Sisor, hast ja weit aus mehr die Erfahrung und Kompetenz, wenn du mein Code schreiben würdest währe er wahrscheinlich nur 1/4 so groß wie
jetzt. Das is das was ich gemeint hab, das ich es momentan noch so schreibe das ich es auch verstehe, aber es funktioniert immer besser!
Also wenn ich das so lassen möchte und die Funktion " void scan_VORNE_RECHTS " bleiben soll - muss ich das void ersetzten nur durch welches?
es gibt float() char() Byte() word() nur welches von denen gibt auch Aussagen zurück?