Hallo :), Ich muss für die Schule ein Projekt schreiben, bei der sich zwei Servos drehen müssen. Auf dem ersten Servo ist ein Lichtsensor drauf und auf dem zweiten Sensor eine Solarpanele. Der Servo mit dem Sensor soll sich pausenlos drehen und die Helligkeit messen. Die Position, an der der Wert (Helligkeit) am größten ist, soll dem Servo mit der Panele mitgeteilt werden und dieser soll sich demnach ausrichten. :) Wäre nett, wenn ihr mir helfen könntet :) Danke für eure Hilfe :) N(ew)(oo)bie
:
Verschoben durch User
N(ew)(oo)bie schrieb: > Ich muss für die Schule ein Projekt schreiben Ich glaube eher ein Programm schreiben :D
N(ew)(oo)bie schrieb: > Hallo :), > > Ich muss für die Schule ein Projekt schreiben, bei der sich zwei Servos > drehen müssen. Auf dem ersten Servo ist ein Lichtsensor drauf und auf > dem zweiten Sensor eine Solarpanele. Der Servo mit dem Sensor soll sich > pausenlos drehen und die Helligkeit messen. Die Position, an der der > Wert (Helligkeit) am größten ist, soll dem Servo mit der Panele > mitgeteilt werden und dieser soll sich demnach ausrichten. Und das ganze mit einem PC? Abgesehen davon. Wo liegt das Problem? Anders ausgedrückt: Dein Projekt besteht ja aus mehreren Teilen bzw. Programm-'Baugruppen' oder Teilproblemen. Welche davon kannst du alleine?
Sorry, hab noch vergessen, dass das ganze in Mikropascal geschrieben werden muss :) . Wenn das so rüber kommt, als wollte ich, dass ein anderer für mich die Arbeit machen soll, dann habe ich mich falsch ausgedrückt. Ich brauche lediglich einen Denkanstoß :)
Karl Heinz Buchegger schrieb: > Und das ganze mit einem PC? > > > Abgesehen davon. Wo liegt das Problem? > Anders ausgedrückt: Dein Projekt besteht ja aus mehreren Teilen bzw. > Programm-'Baugruppen' oder Teilproblemen. Welche davon kannst du > alleine? Mein größtes Problem besteht im Servo mit dem Sensor. Ich bekomme ihn nicht gescheit gedreht: Das heißt, der Servo soll sich sich ein winzig bisschen drehen, Helligkeit messen, winzig bisschen weiter drehen, Helligkeit messen usw. bis zum Anschlag und dann das ganze zurück. Mit was sonst, anstatt PC?
N(ew)(oo)bie schrieb: > Mein größtes Problem besteht im Servo mit dem Sensor. Ich bekomme ihn > nicht gescheit gedreht: Das heißt, der Servo soll sich sich ein winzig > bisschen drehen, Helligkeit messen, winzig bisschen weiter drehen, > Helligkeit messen usw. bis zum Anschlag und dann das ganze zurück. Mit > was sonst, anstatt PC? Okay. Was hast Du bereits getan? Wie sind die Servos mit dem PC verbunden? Zeig uns mal den Schaltplan und Deinen bisherigen Code...
N(ew)(oo)bie schrieb: > Mit > was sonst, anstatt PC? Weil Servoansteuerung in erster Linie eine Frage der Einhaltung von exakten Pulszeiten ist. Die kann dir aber ein PC unter zb Windows nicht garantieren. Wenn Windows ein Päuschen einlegt um den Speicher aufzuräumen, ist es vorbei mit Millisekundentimings. Für Servos benutzt man eine dezifierte Elektronik, zb in Form eines µC, welcher kein Betriebssystem hat und daher kein Problem hat, die Pulstimings exakt einzuhalten, bzw. die Pulse in exakt der benötigten Zeit in Hardware zu erzeugen. Aber egal: Wie ist an deinem PC was angeschlossen?
Hmm :/ das mit dem bisherigen Code und dem Schaltplan wird schwer, da ich ihn in der Schule auf einem Laptop ohne jeglichen Anschluss ans Internet gespeichert habe :/ . Achso ist das gemeint. Nein nein wir haben eine µC (Atmega8, MK2 oder so :) ). Bisher hab ich eigentlich noch nicht viel, da ich die Grundlage nicht erstellen kann... Also das mit dem Drehen und Werte messen :/ Patrick schrieb: > Okay. > > Was hast Du bereits getan? > Wie sind die Servos mit dem PC verbunden? > Zeig uns mal den Schaltplan und Deinen bisherigen Code...
N(ew)(oo)bie schrieb: > Hmm :/ das mit dem bisherigen Code und dem Schaltplan wird schwer, da > ich ihn in der Schule auf einem Laptop ohne jeglichen Anschluss ans > Internet gespeichert habe :/ . Achso ist das gemeint. Nein nein wir > haben eine µC (Atmega8, MK2 oder so OK. Dann verschieb ich das mal, wo es hingehört. Denn mit PC-Programmierung hat das ganze dann eigentlich nicht viel zu tun. Denn die eigentliche Arbeit wird ja der µC machen. Selbst wenn da eventuell vom PC der eine oder andere Befehl zum µC schickt. Das Programm welches die eigentliche Arbeit macht, läuft auf dem µC. Und dafür schreibst du das Programm. Selbst wenn du das Programm auf dem PC tippst :-)
Ich hab das mit PC-Programmierung so interpretiert, dass ich das Programm auf dem PC schreibe :D . Also den µC vom PC aus programmiere! :)
N(ew)(oo)bie schrieb: > Ich hab das mit PC-Programmierung so interpretiert, dass ich das > Programm auf dem PC schreibe :D . Also den µC vom PC aus programmiere! > :) Das interessiert wiederrum keinen. Und wenn du dein Programm so schreibst, dass du Bierflaschen einmal richtig rum und einmal verkehrt rum aufstellst und so 0-en und 1-en repräsentierst. Deswegen bist du trotzdem in einem Getränkeforum falsch :-) Es zählt immer der Computer, auf dem das Programm dann laufen wird. Denn für den muss das Programm geschrieben werden.
Karl Heinz Buchegger schrieb: > Das interessiert wiederrum keinen. > Und wenn du dein Programm so schreibst, dass du Bierflaschen einmal > richtig rum und einmal verkehrt rum aufstellst und so 0-en und 1-en > repräsentierst. Deswegen bist du trotzdem in einem Getränkeforum falsch > :-) Hahah stimmt :). Dann wieder zurück zum Thema. Was wären Möglichkeiten um das mit dem Drehen und dabei Werte messen und speichern zu realisieren?
N(ew)(oo)bie schrieb: > Karl Heinz Buchegger schrieb: >> Das interessiert wiederrum keinen. >> Und wenn du dein Programm so schreibst, dass du Bierflaschen einmal >> richtig rum und einmal verkehrt rum aufstellst und so 0-en und 1-en >> repräsentierst. Deswegen bist du trotzdem in einem Getränkeforum falsch >> :-) > > Hahah stimmt :). Dann wieder zurück zum Thema. Was wären Möglichkeiten > um das mit dem Drehen und dabei Werte messen und speichern zu > realisieren? Na ja. Was hast du denn bisher? Wie hast du deine Servoansteuerung realisiert? (Ich mein jetzt programmtechnisch) Lassen wir die Sache mit dem Sensor erst mal aussen vor. Erst mal müssen sich die Servos sauber bewegen. Die Strategie hast du ja oben schon skizziert und die ist ja auch in Ordnung so. Also lassen wir erst mal alles weg, was nicht zum ersten Detailproblem gehört. Und das erste Detailproblem lautet: 2 Servos unabhängig voneinander ansteuern und zwar so, dass man jedem Servo eine Position vorgibt und die fährt es dann an.
Also ich glaube ich muss erst mal einen Servo zum Laufen/Stottern(im Sinne von bisschen bewegen, dann stop... s.o.) bringen. Ich hab das ganze mit einer procedure gemacht (Bewirkt das, was delay_us auch macht), da man in die () von delay_us keine Variable einfügen kann. Den Befehl, dass sich der Servo drehen soll, habe ich in eine for-Schleife gepackt.
Karl Heinz Buchegger schrieb: > Detailproblem lautet: 2 Servos unabhängig voneinander ansteuern und zwar > so, dass man jedem Servo eine Position vorgibt und die fährt es dann an. Wobei ich vorschlagen würde, dass wir das zuerst mal auf die primitive Banalversion machen, da dein Programm nicht wirklich zeitkritisch sein wird. D.h. wir werden die Servopulse erst mal mittels Verzögerungsschleifen realisiern. Ein Profi würde das zwar anders machen, aber ich weiß nicht, auf welchen Grundlagen ich bei dir aufbauen kann. Also geh ich mal vom kleinsten gemeinsamen Nenner aus.
N(ew)(oo)bie schrieb: > Also ich glaube ich muss erst mal einen Servo zum Laufen/Stottern(im > Sinne von bisschen bewegen, dann stop... s.o.) bringen. Ich hab das > ganze mit einer procedure gemacht (Bewirkt das, was delay_us auch > macht), da man in die () von delay_us keine Variable einfügen kann. Den > Befehl, dass sich der Servo drehen soll, habe ich in eine for-Schleife > gepackt. Jetzt wärs halt gut, wenn man mal sehen könnte, was du da GENAU gemacht hast. Wie gesagt: Ein Profi würde das mit einem Timer machen, aber mit einer Warteschleife wirds fürs erste auch gehen.
Wir haben for, while und repeat Schleifen kennengelernt, Servo An/Aus, Deklarationen, Lcds, LEDs und an Verzögerungen halt delay_xx. Mein Lehrer hat mir heute noch den Begriff procedure erklärt, da man wiegesagt bei delay keine Variable einfügen kann :/
N(ew)(oo)bie schrieb: > Wir haben for, while und repeat Schleifen kennengelernt, Servo An/Aus, > Deklarationen, Lcds, LEDs und an Verzögerungen halt delay_xx. Mein > Lehrer hat mir heute noch den Begriff procedure erklärt, da man > wiegesagt bei delay keine Variable einfügen kann :/ Wichtig wäre zu wissen, ob das Micropascal eine fertige Verzögerungsfunktion hat. Denn deine eigene wird nur so leidlich funktionieren. Ich kenne Micropascal nicht, d.h. du musst da ein wenig mithelfen.
Hmm. Ist eigentlich mehr von meinem Lehrer. Ich weiss nicht genau. Könnte sein, dass so eine Verzögerungsfunktion am Rande erwähnt wurde :) . Zur Not wäre es auch nicht schlimm, wenn ich eine verwenden würde, die wir noch nicht gelernt haben. Das Projekt konnte sich jeder selber überlegen und somit hat man ja auch seine eigene Freiheit! :) Wie ich heute mal wieder laber -.- .
Hm, irgendwie alles ein komischer Grundansatz. Die einfache Variante: du brauchst nur ne Uhr/Kalender. Daraus kann man ziemlich zuverlässig den exakten Sonnenstand errechnen und die Panele dahin positionieren. Wenn die eigentliche Aufgabe nun aber darin besteht, tatsächlich der Sonne mittels Sensor zu folgen, macht es für mich keinen Sinne, dafür 2 getrennte Antriebseinheiten zu verwenden. Bringt keinerlei Vorteile, aber ne Menge Nachteile. Der sinnvollste Weg , falls das unbedingt mit Sensor gemacht werden soll, montiere den Sensor mit auf das zu bewegende Panel. Und in echt wird das direkt mit der Solarzelle als Sensor gemacht (such mal nach MPPT)
H.joachim Seifert schrieb: > Wenn die eigentliche Aufgabe nun aber darin besteht, tatsächlich der > Sonne mittels Sensor zu folgen, macht es für mich keinen Sinne, dafür 2 > getrennte Antriebseinheiten zu verwenden. Bringt keinerlei Vorteile, > aber ne Menge Nachteile. naja, Lernaufgaben können durchaus manchmal etwas anders sein als die Realität. Immerhin ist bei dem vorgegebenen Ansatz auch noch etwas (Inter-Przes-) Kommunikation gefragt. Davon ab: Der Ansatz "dreh dich einmal in Kreis und schaue, wo es am hellsten ist" macht MIT Panel weniger Sinn, als wenn das Guck-Ding seperat angesteuert wird. Ob die Nachführung grundsätzlich "was bringt", und ob die mathematisch ermittelte theoretische Maximalposition der Sonne noch mit einbezogen werden kann doer soll, sind halt ganz andere FRagen.
Lass ich mir mal durch den Kopf gehen :) . Danke! :)
Wegstaben Verbuchsler schrieb: > H.joachim Seifert schrieb: > naja, Lernaufgaben können durchaus manchmal etwas anders sein als die > Realität. Immerhin ist bei dem vorgegebenen Ansatz auch noch etwas > (Inter-Przes-) Kommunikation gefragt. > > Davon ab: Der Ansatz "dreh dich einmal in Kreis und schaue, wo es am > hellsten ist" macht MIT Panel weniger Sinn, als wenn das Guck-Ding > seperat angesteuert wird. Ob die Nachführung grundsätzlich "was bringt", > und ob die mathematisch ermittelte theoretische Maximalposition der > Sonne noch mit einbezogen werden kann doer soll, sind halt ganz andere > FRagen. Hmm. Ja nach dem Argument (nicht ganz so fachlich) habe ich gesucht :) . Da ich noch mit anderen in einer Gruppe bin ist das nicht so ganz einfach nochmal das komplette Projekt zu ändern. Deswegen bleibe ich bei der Version und benötige immer noch einen Vorschlag wie man das realisiert :)
Bin dann mal offline. Werde mich höchstwarscheinlich morgen hier wieder melden :) . Bis dann!
am besten meldest du dich auch noch an im Forum, dann kann man dir auch noch eine persönliche Mail senden bei Bedarf, und du bekommst eine Benachrichtigung, falls sich hier im Thread was tut (weitere Beiträge von Mitschreibern)
Ok, gut, dann ist die Aufgabe eben so. Auf jeden Fall solltest du als erstes in Erfahrung bringen, wie du in deinem Pascal den Timer1 des ATMega8 zum laufen bringst (das geht auf jeden Fall, sonst wäre die Sprache nutzlos). Und wenn du dann noch die beiden Servos an OCR1A und OCR1B anschliesst, ist der ganze Rest ein Kinderspiel. Mit delay oder einer ähnlichen Funktion wirst du nicht wirklich glücklich werden.
H.joachim Seifert schrieb: > Ok, gut, dann ist die Aufgabe eben so. Ich denke auch, dass das Hauptaugenmerk nicht auf der Praktikabilität liegt, sondern dass es darum geht etwas zu Programmieren. Und wenn ich so interpretiere, was der TO so von sich gegebe hat, dann steht er wirklich gaaaanz am Anfang. Es könnte auch sein, dass er sich selbst in die Breduille geritten hat, in dem er vollmundig den Mund zu voll genommen hat. Denn aus heiterem Himmel macht man nicht so ein Projekt, wenn man noch bei 0 steht. > Und wenn du dann noch die beiden Servos an OCR1A und OCR1B anschliesst, > ist der ganze Rest ein Kinderspiel. Mit delay oder einer ähnlichen > Funktion wirst du nicht wirklich glücklich werden. Ich geb dir zwar grundsätzlich recht. Meine Befürchtung ist aber eher, dass es nicht viel bringt, wenn er die ersten 20 oder 30 Übungsstunden überspringt und gleich zu Timern wechselt. Er wird sie bzw den ganzen Ansatz nicht verstehen. Schwierige Situation.
Hilft ja nichts - mit dem A/D-Wandler muss er sich ja auch beschäftigen, sonst wirds ja nichts mit der Helligkeitsmessung. Also Timer gleich mit :-) Ich seh eh in der Helligkeitsmessung das grösste Problem, zumindest wenn tatsächlich die Sonne das Objekt der Begierde sein soll (im Studierzimmer mit Lampen wird es einfach sein) - da geht die Beleuchtungsstärke über mehrere Grössenordnungen. Da wird es wohl einige Kunstgriffe benötigen, wenn es sowohl bei leichter Bewölkung als auch im Sommer Mittags bei blauem Himmel funktionieren soll :-)
Hallo :) . In die Predouille hab ich mich nicht gebracht. Wir haben uns das Projekt gemeinsam überlegt und wenn man es auf die einfache Art macht, ist es auch nicht so schwer. Hab auf jeden Fall mal den Quelltext aus der Schule mitgebracht, was ich bis jetzt schon habe.
1 | program Solaranlage; |
2 | VAR |
3 | i:integer; |
4 | Akt_Pos:integer; |
5 | Max:integer; |
6 | |
7 | procedure verzoeger(pause:integer); |
8 | var u:integer; |
9 | begin |
10 | //delay_us(1000); |
11 | for u:=1 to pause do |
12 | begin |
13 | delay_us(10); |
14 | end; |
15 | end; |
16 | |
17 | begin |
18 | ddrb.0:=1; |
19 | |
20 | ddrb.1:=1; |
21 | |
22 | while(true) do |
23 | begin |
24 | portb.0:=1; |
25 | |
26 | for i:=1 to 10 do |
27 | begin |
28 | PortB.1:=1; |
29 | verzoeger(100); |
30 | PortB.1:=0; |
31 | delay_ms(10); |
32 | end; |
33 | |
34 | delay_ms(2000); |
35 | portb.0:=0; |
36 | |
37 | for i:=1 to 40 do |
38 | begin |
39 | PortB.1:=1; |
40 | verzoeger(200); |
41 | PortB.1:=0; |
42 | delay_ms(10); |
43 | end; |
44 | delay_ms(2000); |
45 | |
46 | end; |
47 | |
48 | end. |
Ich hoffe der Text ist nicht zu lang, sonst werde ich ihn beim nächsten Mal in den Anhang packen :) !
N(ew)(oo)bie schrieb: > delay_ms(2000); Das kannst du nicht machen. Dein Servo will ständig(!) Pulse von dir haben. 2 Sekunden keine Pulse geht gar nicht. Wenn du eine Position halten willst, dann musst du dir eben ausrechnen, wieviele Wiederholungen du hier for i:=1 to 10 do brauchst, damit das 2 Sekunden werden. delay_ms kannst du dir ab sofort abschminken, wenn du in deinem Programm eine Zeitlang nichts tun willst. Denn dein Programm darf nicht 'nichts tun'. Es muss Servo-Pulse generieren! Und zwar dauernd.
Ok alles klar, dann lasse ich das weg. Jedoch dreht der Servo sich nicht stockend, sondern ein paar Millimeter und dann in die andere Richtung. Eigentlich sollte er 180° in die eine Richtung stottern und 180° in die andere :/
N(ew)(oo)bie schrieb: > Ok alles klar, dann lasse ich das weg. Jedoch dreht der Servo sich nicht > stockend, sondern ein paar Millimeter und dann in die andere Richtung. Na ja. Was glaubst du, wie weit sich dein Servo in 0.1 Sekunden drehen kann? Das Servo bewegt sich nur, solange es Pulse bekommt! Wenn du ihm 2 Sekunden keine Pulse schickst, dreht es auch nicht. Jetzt dreht es 0.1 Sekunden auf die Position 100 hin und 2 Sekunden später dreht es sich auf die Position 200 hin. Diesmal 0.4 Sekunden. Um dann wieder 2 Sekunden nichts zu tun und sich wieder 0.1 Sekunden in Richtung Position 100 zu drehen.
Ja aber er muss ja kurz noch den Wert messen, bis er wieder weiter stottert. Also nach jedem mikro-Meter oder vielleicht auch milli-Meter (so, dass er den hellsten Punkt möglichst genau ausfindig machen kann) muss er messen.
N(ew)(oo)bie schrieb: > Ja aber er muss ja kurz noch den Wert messen, bis er wieder weiter > stottert. Laaaaaaaaangsam. Eines nach dem anderen. Messen kommt später. Jetzt siehst du erst mal zu, dass du verstehst, wie man ein Servo ansteuern muss. Und um das auch gleich anzusprechen. Dein Programm wird sowieso nicht so bleiben, wie es jetzt aussieht. Sieh es als Testprogramm an, mit dem du lernst, wie man mit einem Servo (na ja) umgeht. Da bleibt sowieso kein Stein auf dem anderen. Selbst wenn du die Servopulse mittels Verzögerungssschleife generierst, ist der ganze Ansatz mit den for-Schleifen unbrauchbar und muss durch etwas clevereres ersetzt werden.
Alles klar. Also wie sollte ich weiter vorgehen?
N(ew)(oo)bie schrieb: > Alles klar. Also wie sollte ich weiter vorgehen? Das dein Servo sauber von einer Endposition in die andere fährt. Dazu musst du ihm ständig Pulse schicken. (Ich will eigentlich nur wissen, ob das grundsätzlich funktioniert ohne jetzt allzuviel ändern zu müssen) Und dann bauen wir deine beiden for-schleifen mal auf etwas Clevereres um.
Ok. Also das ganze funktioniert nur, wenn ich das ganz einfach mach. Also mit Servo an, delay_us(1000) usw.
N(ew)(oo)bie schrieb: > Ok. Also das ganze funktioniert nur, wenn ich das ganz einfach mach. > Also mit Servo an, delay_us(1000) usw. Jo. Dann will ich mal annehmen, dass Hardware und Takfrequenz grundsätzlich in Ordnung sind. OK. wie macht man das cleverer. Grundsätzlich: Deine ganze for-schleife mit der du eine bestimmte Anzahl Pulse erzeugst, die legst du gleich mal ad acta. Dein Hauptrpgramm wird so aussehen
1 | program Solaranlage; |
2 | VAR |
3 | i:integer; |
4 | Akt_Pos:integer; |
5 | Max:integer; |
6 | |
7 | procedure verzoeger(pause:integer); |
8 | var u:integer; |
9 | begin |
10 | //delay_us(1000); |
11 | for u:=1 to pause do |
12 | begin |
13 | delay_us(10); |
14 | end; |
15 | end; |
16 | |
17 | begin |
18 | ddrb.0:=1; |
19 | ddrb.1:=1; |
20 | |
21 | Akt_Pos := 100; |
22 | |
23 | while(true) do |
24 | begin |
25 | |
26 | |
27 | /* .... */ |
28 | |
29 | /* den entsprechenden Servopuls erzeugen */ |
30 | |
31 | portb.0 := 1; |
32 | verzoeger( Akt_Pos ); |
33 | PortB.0 := 0; |
34 | |
35 | delay_ms(10); |
36 | end; |
37 | |
38 | end. |
D.h. du erzeugst bei jedem Durchgang durch die Hauptschleife EINEN und NUR EINEN Servopuls. Dafür kannst du dir Methoden überlegen, wie du an der Stelle
1 | /* .... */ |
die Variable Akt_Pos entsprechend veränderst. zb. kannst du sie nach jeweils 10 Durchläufen durch die Hauptschleife um 1 erhöhen oder verringern.
1 | program Solaranlage; |
2 | VAR |
3 | i:integer; |
4 | Akt_Pos:integer; |
5 | Max:integer; |
6 | |
7 | procedure verzoeger(pause:integer); |
8 | var u:integer; |
9 | begin |
10 | //delay_us(1000); |
11 | for u:=1 to pause do |
12 | begin |
13 | delay_us(10); |
14 | end; |
15 | end; |
16 | |
17 | begin |
18 | ddrb.0:=1; |
19 | ddrb.1:=1; |
20 | |
21 | Akt_Pos := 100; |
22 | i := 0; |
23 | |
24 | while(true) do |
25 | begin |
26 | |
27 | i := i + 1; |
28 | if i = 10 then |
29 | begin |
30 | i := 0; |
31 | if Akt_Pos < 200 then |
32 | Akt_Pos := Akt_Pos + 1; |
33 | end; |
34 | |
35 | /* den entsprechenden Servopuls erzeugen */ |
36 | |
37 | Portb.0 := 1; |
38 | verzoeger( Akt_Pos ); |
39 | PortB.0 := 0; |
40 | |
41 | delay_ms(10); |
42 | end; |
43 | |
44 | end. |
Ok. Das heisst der Servopuls sollte so aussehen:
Akt_Pos := 100;
i := 0;
while(true) do
begin
i := i + 1;
if i = 10 then
begin
i := 0;
if Akt_Pos < 200 then
Akt_Pos := Akt_Pos + 1;
end;
?
N(ew)(oo)bie schrieb: > Ok. Das heisst der Servopuls sollte so aussehen: > Akt_Pos := 100; > i := 0; > > while(true) do > begin > > i := i + 1; > if i = 10 then > begin > i := 0; > if Akt_Pos < 200 then > Akt_Pos := Akt_Pos + 1; > end; Das variiert den Servopuls, indem es die Länge des Pulses verändert, indem der WErt von Akt_Pos verändert wird. Diese Variable wird ja dann in weiterer Folge hier Portb.0 := 1; verzoeger( Akt_Pos ); PortB.0 := 0; verwendet, um den tatsächlichen Puls zu erzeugen. Veränderst du Akt_Pos, veränderst du auch den Servopuls und das Servo reagiert darauf. D.h. dein "Problem" hat sich insofern verlagert, als du dir jetzt Strategien ausdenken kannst, wie du gezielt Akt_Pos bei jedem Durchlauf durch die Schleife verändern musst/kannst. Zum Beispiel in kleinen Schritten, in dem du nur bei jedem 10.ten Durchlauf Akt_Pos um 1 erhöhst. Da du weist, dass ein Durchlauf ca. 10ms dauert, bedeutet das, das Akt_Pos (und damit auch das Servo) alle 10*10 -> 100ms sich um 1 erhöht. 100ms, das sind 0.1 Sekunden. Alle 0.1 Sekunden wird also der Servopuls ein wenig verändert (größer gemacht). Und da das Servo diesem Puls folgt, verändert es alle 0.1 Sekunden seine Position ein klein wenig von einer Endstellung in die andere (und bleibt dann stehen, weil sich dann ja auch Akt_Pos nicht mehr verändert) Das ist jetzt noch nicht ganz der komplette Code, wie du das Servo von einer Endstellung in die andere fahren lassen kannst, aber es ist ein Schritt in diese Richtung. Ich will dir ja nicht dein Programm komplett schreiben. Ist ja schliesslich dein Projekt.
Alles klar. Werde das morgen in der Schule ausprobieren und mich dann abends nochmal melden :) . Danke!
Mein Lehrer hat das nochmal mit mir überarbeitet, bzw den Servopuls eingefügt. Das sieht jetzt so aus, aber funktioniert nicht richtig:
1 | program Solaranlage; |
2 | VAR |
3 | i:integer; |
4 | Akt_Pos:integer; |
5 | Max:integer; |
6 | s:integer; |
7 | |
8 | procedure verzoeger(pause:integer); |
9 | var u:integer; |
10 | begin |
11 | //delay_us(1000); |
12 | for u:=1 to pause do |
13 | begin |
14 | delay_us(10); |
15 | end; |
16 | end; |
17 | procedure Servo_Puls(Pulslaenge:integer); |
18 | var x:integer; |
19 | begin |
20 | for x:=0 to 30 do |
21 | begin |
22 | PortB.0:=1; |
23 | verzoeger(Pulslaenge); |
24 | PortB.0:=0; |
25 | delay_ms(10) |
26 | end; |
27 | end; |
28 | begin |
29 | ddrD.2:=1; //Deklaration LED |
30 | ddrb.0:=1; |
31 | ddrb.1:=1; |
32 | |
33 | Akt_Pos := 100; |
34 | i := 0; |
35 | |
36 | while(true) do |
37 | begin |
38 | PortD.2:=1; //LED an |
39 | i := i + 1; |
40 | |
41 | if i = 10 then |
42 | begin |
43 | i := 0; |
44 | if Akt_Pos < 200 then |
45 | Akt_Pos := Akt_Pos + 1; |
46 | end; |
47 | for s:=100 to 200 do |
48 | begin |
49 | Servo_Puls(s); |
50 | end; |
51 | for s:=200 downto 100 do |
52 | begin |
53 | Servo_Puls(s); |
54 | end; |
55 | |
56 | Portb.0 := 1; |
57 | verzoeger( Akt_Pos ); |
58 | PortB.0 := 0; |
59 | |
60 | delay_ms(10); |
61 | end; |
62 | |
63 | end. |
N(ew)(oo)bie schrieb: > aber funktioniert nicht richtig: welche Funktion erwartest du? Was pasiert statt desen?
Er dreht sich einmal kurz (nicht 180°) und stottert einmal kurz (auch nicht 180°). Ich erwarte, dass er 180° in die eine Richtung stottert und 180° zurück stottert. Das ganze dauerhaft!
geh doch einfach mal das Programm auf einem Blatt Papier durch, auf dem du die einzelnen Variablen und dessen Werte aufschreibst (Bleistift und Radiere sind hilfreich)
Da der letzte Hüpfer der Sonne bereits mehrere Milliarden Jahre her ist und in den näheren Zukunft mit circa einer Umdrehung pro Tag zu rechnen ist, kannst Du "Schnell" als erstes Mal vergessen. - Also einen kleinen, billigen Getriebemotor mit möglichst hoher Untersetzung. - In der Verlängerung der Motorachse bringst Du ein Potentiometer an. Die meisten können 270°. Selbst auf der Zugspitze kommst Du nur knapp über 180° Blickwinkel. Falls Du zur ängstlichen Sorte gehörst: Entweder zum Anfang das Poti nicht ganz festschrauben, oder eins ohne Anschlag nehmen. - An den beiden Endlagen einen kleinen Endschalter mit einer Rückfahrdiode so anbringen, dass ein Bereich von etwa 200° abgefahren werden kann. Die unterbrechen Dir den Motorstrom für die eine Richtung, wenn Du mal das Poti "verpasst" hast. - Auf der Achse befindet sich auch Dein Lichtsensor. : Wenn Du jetzt das System, langsam von der einen Seite zur anderen fahren lässt, brauchst Du nur den gemessenen Sensorwert beobachten. Geht dieser "zurück", so liest Du das Poti aus und hast das Maximum. : Wenn Du das Poti genau im Auge behältst, kannst Du Dir sogar die Endschalter einsparen. = Das Ganze kann mit einem einfachen µP mit zwei A/D-Wandlern aufgebaut werden. Sowie zwei Ports für die Motorsteuerung. Wenn Du dauernd hin und her fahren willst, reicht auch ein Port.
Ok. Der alte Thread ist anscheinend gelöscht/geschlossen. Also wie ich schon sagte, ist alles gebaut und geplant, also würde ich mich freuen, wenn ich nicht andauern lesen müsste, dass es anders viel einfacher geht! Mein Problem zuerst ist, dass der Servo nicht stottern will. (immer 180° stottern und zurück!)
Kleine Anregung: http://de.wikipedia.org/wiki/Extremwertregler Denn das Photovoltaikpanel selbst ist ja schon ein Lichtsensor. Damit macht ihr die genaue Ausrichtung. Der kleine Lichtsensor gibt nur die ungefähre Position vor. Der muss dann auch nicht "stottern".
Ich glaube nicht, dass ich das noch einrichten kann... Ist ja schon gebaut und geplant. Mein Problem ist auch nicht das Projekt an sich sondern die Servos.
Also, woran ich gerne anknüpfen würde wäre die obrige Unterhaltung mit
Herrn Buchegger. Das Skript habe ich noch nicht so ganz verstanden, und
letzten Endes zeigt der Servo damit auch nicht wirklich die
beabsichtigten Reaktionen. Was habe ich vergessen, bzw. falsch gemacht?
Das Skript sieht so aus:
program Solaranlage;
VAR
i:integer;
Akt_Pos:integer;
Max:integer;
s:integer;
procedure verzoeger(pause:integer);
var u:integer;
begin
//delay_us(1000);
for u:=1 to pause do
begin
delay_us(10);
end;
end;
procedure Servo_Puls(Pulslaenge:integer);
var x:integer;
begin
for x:=0 to 30 do
begin
PortB.0:=1;
verzoeger(Pulslaenge);
PortB.0:=0;
delay_ms(10)
end;
end;
begin
ddrD.2:=1; //Deklaration LED
ddrb.0:=1;
ddrb.1:=1;
Akt_Pos := 100;
i := 0;
while(true) do
begin
PortD.2:=1; //LED an
i := i + 1;
if i = 10 then
begin
i := 0;
if Akt_Pos < 200 then
Akt_Pos := Akt_Pos + 1;
end;
for s:=100 to 200 do
begin
Servo_Puls(s);
end;
for s:=200 downto 100 do
begin
Servo_Puls(s);
end;
Portb.0 := 1;
verzoeger( Akt_Pos );
PortB.0 := 0;
delay_ms(10);
end;
end.
Ich habe auch schon ewig im Internet nach Anleitungen zum Servo kontrollieren geschaut. Wenn ich welche finde, dann sind das nur welche für Fortgeschrittene ... :(
H.joachim Seifert schrieb: > Ok, gut, dann ist die Aufgabe eben so. Würde vielleicht auf einem Boot Sinn machen oder auf der ISS :-D
Hmm. Jetzt habe ich was gefunden: Und zwar habe ich gelesen, dass man dem Servo immer zuerst High oder Low sagen muss. Inwiefern stimmt das oder ist das eine andere Programmiersprache?
Tim Z. schrieb: > Hmm. Jetzt habe ich was gefunden: Und zwar habe ich gelesen, dass man > dem Servo immer zuerst High oder Low sagen muss. Es ist schwierig mit dir. Was glaubst du, was du hier Portb.0 := 1; verzoeger( Akt_Pos ); PortB.0 := 0; tust? High ist in der Digitaltechnik nichts anderes als ein anderes Wort für 1. Low steht für 0. Ob das jetzt 'Spannung da', 'Wasser fliesst', 'Sonne scheint', 'High' oder '1' heißt, ist nur eine Bezeichnungssache. Digitaltechnik bedeutet: es gibt nur 2 Zustände. Und der eine ist das Gegenteil vom anderen. Das Problem ist, dass du ziemlich daneben stehst. Du hast von dem Code, den ich dir angetragen habe nicht das geringste verstanden. Und dabei hab ich ihn schon so einfach wie nur irgendwie möglich gemacht. Im Grunde müsste man mit dir bei 0 anfangen. Drum hab ich mich auch zurückgezogen. Denn eigentlich ist das der Job deines Lehrers.
Tut mir Leid. Hab das halt noch nicht so ganz verstanden. Werde mich anstrengen! Bei 0 würde ich nicht umbedingt sagen. Ich möchte erst einmal nur wissen wie man Servos steutert. Hin und zurück. Bei mir macht der Servo das nie . Das Portb.0 := 1; verzoeger( Akt_Pos ); PortB.0 := 0; ist der Servopuls, den mein Lehrer mir eingefügt hat. Er soll den Port B verwenden und dann die procedure verzoeger ausführen!
H.joachim Seifert schrieb: > Hilft ja nichts - mit dem A/D-Wandler muss er sich ja auch beschäftigen, > sonst wirds ja nichts mit der Helligkeitsmessung. Auch wenn der Beitrag schon älter ist: Da reicht ein Ein-Bit-Wandler. Der nennt sich auch Komparator. Dahinter ein einfaches IIR-Filter und man hat seinen Helligkeitsvergleicher für die Regelung der Position.
Tim Z. schrieb: > ist der Servopuls, den mein Lehrer mir eingefügt hat. Er soll den Port B > verwenden und dann die procedure verzoeger ausführen! Ja. Aber da steckt was dahinter! Einen Code begreifen bedeutet nicht, dass man ihn nur vorlesen kann. Die Bedeutung dieses Codes ist es, dass er einen Low-High-Low Puls erzeugt, wobei die Pulslänge durch Akt_Pos einstellbar ist. Das ist das, worauf es bei diesem Codeausschnitt ankommt. Auf der Leitung zum Servo ergibt das diesen Spannungsberlauf Spannung | +-------+ +------+ | | | | | | | | | | | --+ +-----------------+ +---- -+------------------------------------------> Zeit ^ ^ |+-----+| | | PortB.0 := 0 | | | verzoeger( Akt_Pos ); | PortB.0 := 1 und das ist genau das, was das Servo braucht. Einen Puls der je nach gewünschter Servoposition 1 bis 2 ms lang ist. Das Akt_Pos, also die Wartezeit zwischen dem Anlegen des High-Pegels und der Rücknahme auf Low, ist genau dein Mittel um diese Zeit einzustellen. (Und natürlich, wie man in der Zeichnung sieht: nach einer gewissen Zeit muss dieser Puls erneut kommen. Dauernd. Laufend. So um die 50 mal in der Sekunde. Zu schnell darf er auch nicht kommen, daher zwischendurch die Wartezeit von 10ms)
Ok, das habe ich auch so im Unterricht wahrgenommen. Jetzt hat das nur leider nicht funktioniert. Ist ein Fehler im Programm oder muss ich einfach nur die Werte der Variablen verändern. Also z.B. den Wert von Akt_Pos?
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.