Könnt ihr mit helfen? Solarzelle...

Mein Gott bitte ich krieg ne 5

PRIEST

Also wenn alle aus der Klasse das nicht können müsst ihr mit eurem Lehrer "Reden".
Also ich kann mich da nicht einfinden und dir ne Lösung geben .. und ich denke andere können das jetzt auch nicht und haben keine zeit dafür.. sorry

Na gut. NÃ¤chste Stunde faengt der Test an. Mal schauen ob ich was hinbekomme. Wenn nicht eben ne 6. Koennt dann schliessen......

Wir haben nächste Woche auch nochmal zeit dafür dann wird benotet ob man es geschafft hat...

Ich weiss jetzt 100% wie der Microcontrollr heisst:

Siemens
SAB 80C515/80C535
8-Bit Microcontroller

Nagila Hawa

Ah ja, der ist schön einfach zu programmieren. Der Befehlssatz ist recht einfach. Such mal nach 8051 bei Google, da sollte es einiges zu geben.

Ansonsten zur Aufgabe: Wenn ihr bisher noch nicht wußtet, welcher Controller das ist und wie man ihn programmiert, was habt ihr denn die ganze Zeit gemacht? Ich denke mal euch wird da noch einiges erklärt werden.

Der Schrittmotor soll einmal in Nullstellung, einmal 60 Schritte weiter stehen? Dann brauchst du 2 Unterprogramme, die den nach vorne, bzw nach hinten bewegt. Du brauchst ein Byte Speicher, der die momentane Position des Motors festhält (nach jedem Schritt nach vorne einmal erhöhen, nach jedem Schritt zurück verringern, mit 0 initialisieren). Je nachdem ob das Eingangssignal LOW oder HIGH ist, bewegst du ihn vor oder zurück, bis Position "0" bzw "60" erreicht ist. Alles natürlich von einem Timer kontrollieren und ein bischen abbremsen lassen, sonst könnte der Schrittmotor ins Straucheln kommen, was ziemlich ärgerlich ist, da du die Position vermutlich nicht nachkontrollieren kannst. Aber bewegt bekommen hast du den Schrittmotor ja schon.

JA das ist ja das Blöde. Es wird nichts mehr erklärt. Nächste Woche Dienstag müssen wir fertig sein mit kompletter Projekt Dokumentation oO
Hallo?

Ja also wenn Licht auf die Solarzelle scheint soll der Schrittmotor 60 nach rechts gehen. Ist das Licht aus oder schwächer geht er wiedr zurück auf 0.

Naja ich schau mal bei Google.

Ich kann euch ja mal zeigen was ih bisher habe aber es ist wohl alles falsch ich weiss nicht weiter!

$IC(sfr.def)
Org 5000H
mov P4,#00001111B

CALL ADW62

Anf:
CALL RECHNEN
CALL MOTOR
CALL ZEIT
JMP Anf

$IC(RECHNEN.DEF)$ IC(ADW62.DEF)
$IC(MOTOR.DEF)$ IC(ZEIT.DEF)
End

ADW62:

clr MX0
Setb MX1
CLR MX2

Setb adm
jb BSY,$
ret

MOTOR:

MOV A,P4
RR a
MOV P4,A

ret

RECHNEN:

mov addat,#255
mov a,#255
subb a,addat

ret

Das rechenn ist auch falsch Helft mir bitte!

Nagila Hawa

Ehrlich gesagt kann ich aus deinem Code nicht genau erkennen, was du vor hast. Mal ein bischen Pseudocode:

Initialisierung:
  RegisterX := 0
Endlosschleife:
  Wenn Sensoreingang High UND RegisterX < 60:
    Motor Vor
    Erhöhe RegisterX
  Wenn Sensoreingang Low UND RegisterX > 0:
    Motor Zurück
    Verringer RegisterX
Ende Endlosschleife

Das sollte eigentlich alles sein.

P.S.: Was willst du denn groß rechnen? Im Moment rechnest du fix 255 - 255, das sollte immer 0 ergeben. "CLR A" macht das gleiche.

Formuliere das, was du vorhast doch mal mit Pseudocode oder einem Ablaufdiagramm, wenn du dann beim Code Schwierigkeiten hast, kann ich dir auch helfen.

Hm, Pseudocode oO Haben wir noch nicht gemacht. Naja es sollte so ablaufen:

START
Liegt Spannung an Solarzelle?
Wenn JA
Motor vor
Wenn NEIN
Motor auf 0

Dann wieder von vorne.
Ja es scheint ja auch einfach zu sein. Aber ich weiss eben nicht welche Befehle ich nehmen muss und welche ich einsetzen soll.

Und das mit dem rechnen hat der Lehrer was gemeint. Wir müssen da was abziehen um rauszubekommen ob Spannung auf der Solarzelle ist. Ja toll...Echt hilfreich wenn man Assembler gerade mal ings. 6 x 45 Minuten gemacht hat.

Dazu hab ich dann auch noch ne Frage:

RR A bewegt doch den Akumulator nach rechts ne? Aber wie mach ich das er nur 100 Schritte zum Beispiel nach rechts geht?

Ich glaube das einzige Problem was ich sonst noch habe sind eben die Befehle zum Abfragen ob Licht bzw. Spannung auf die Solarzelle scheint.

Dann müsst ich ja sonst nur so machen:

$IC(sfr.def)
Org 5000H
CALL ADW62
Anf:
CALL ABFRAGE 
CALL MOTOR
CALL ZEIT
JMP Anf
$IC(ABFRAGE.DEF)
$IC(ADW62.DEF)
$IC(MOTOR.DEF)
$IC(ZEIT.DEF)
End

Und was bei ABFRAGE rein muss weiss ich nicht. Achja und wieso wir dieses ADW62 einbinden sollten weiss ich auch nicht oO

ADW62:

clr MX0
Setb MX1
CLR MX2

Setb adm
jb BSY,$
ret

Nagila Hawa

Dann ist der Lösungsweg schonmal ähnlich wie der von meinem Pseudoprogramm. Das ist gut.

Und was bei ABFRAGE rein muss weiss ich nicht. Achja und wieso wir dieses ADW62 einbinden sollten weiss ich auch nicht oO

Die Funktion dient zur Steuerung des A/D-Wandlers vom Controller... dann sollte der Schrittmotor wohl entsprechend der Lichteinstrahlung auf eine bestimmte Position gebracht werden. Das habe ich gar nicht beachtet, habe ich so aus der Aufgabenstellung auch nicht rausgelesen.

Macht nichts, das ändert das Programm nicht großartig:

Initialisierung:
  RegisterX := 0
Endlosschleife:
  Führe Messung durch
  Wenn RegisterX < ADDAT:
    Motor Vor
    Erhöhe RegisterX
  Wenn RegisterX > ADDAT:
    Motor Zurück
    Verringer RegisterX
Ende Endlosschleife

Jetzt sollte Der Schrittmotor je nach Spannung der Solarzelle zwichen der Position auf dem er zum Start des Controllers steht (Position 0) bis zu Position 255 hin und herwandern.

Zu den Assemblerbefehlen:
Du brauchst Infos zu:
- ADCON (Das Register, das den A/D-Wandler kontrolliert)
- CJNE (Zum Vergleich von zwei Bytes, benutzt das Carry-Flag)
- JC oder JNC (Springt bedingt zum Carry-Flag (Jump if Carry is set/Jump if - Carry is not set
- INC und DEC (Erhöhen b.z.w. verringern eines Bytes)
- MOV (Zum setzen eines Bytes auf einen bestimmten Wert)
- JMP (Sprung)
- CALL (Schmeißt den Inhalt des Programmzählers auf den Stapelspeicher. Springt dann zu der hinter CALL angegebenen Adresse (Aufruf eines Unterprogramms))
- RET (Lädt die obersten zwei Bytes im Stapelspeicher in den Programmzähler (Rücksprung aus einem Unterprogramm))

Das sollten alle Befehle sein, die du benötigst. Ich hoffe ich habe nichts vergessen.

Also entweder ihr habt bisher alle den Unterricht geschwänzt, oder eure Veranstaltung ist etwas seltsam. Was machst du denn genau? Wenn ich fragen darf.

RR A bewegt doch den Akumulator nach rechts ne? Aber wie mach ich das er nur 100 Schritte zum Beispiel nach rechts geht?

RR A bewegt den INHALT des Akkumulators nach Rechts. Aus 00010101 wird 10001010. Jedes einzelne Bit wird also eine Position nach Rechts verschoben. Das, was rechts "rausfällt" wird links eingeschoben. Er macht das nur 1 Schritt, für mehr Schritte brauchst du eine Schleife.

Boah ob ich das hinbekomme
Kann es erst wieder Dienstag testen und da ist dann auch Abgabe. Naja...Keine Ahung ob ich das schaffe, wenn nicht bekomm ich ne 6.

Ich mache Tech. Ass. f. Informatik.

Ja das mit RR A weiss ich ja das in einer Schleife er sich immer weiter bewegt. Aber er soll sich diesmal ja nur 100 Schritte nach rechts bewegen. Mach ich also einfach 100 mal RR A?

PS: Ja der Lehrer ist total schlecht, sieht man ja. Ich check einfach nichts. Und das sieht auch beim Rest der Klasse so aus. Ehrlich gesagt weiss ich selbst jetzt nicht wie ich die Befehle einsetzen sol ich werde es Dienstag mal versuchen. Und falls ich es nicht schaffe schreib ich hier rein und sag euch das ich ne 6 bekommen habe

Nagila Hawa

Die Schuld auf den Lehrer zu schieben ist aber nicht nur ein bischen zu einfach, sondern bringt dir rein gar nichts. Wenn er wirklich so schlecht wäre, daß jede seiner Gruppen nur 6en schreibt, glaubst du er würde dann noch unterrichten? Ich gehe mal nicht davon aus, daß er während der ersten 6 * 45 = 270 Minuten nur Däumchen gedreht oder sich mit euch über Fußball/Boxen unterhalten hat. Er hat also zumindest versucht euch irgendetwas zu erklären und da hätte schon mal nach den ersten 45 Minuten eine Alarmglocke angehen soll, daß das was da so unterrichtet wird nicht ganz angekommen ist.

Einen fertigen Code werde ich dir nicht liefern, auch wenn im Prinzip das Pseudoprogramm schon so formuliert ist, daß man es 1 zu 1 in das nötige Assemblerprogramm übersetzen kann. Das hilft dir nämlich nicht weiter. Setz dich übers Wochenende hin, sag deinen Kumpels ab und du hast definitiv genug Zeit um das bis Montag hinzubekommen. Was spricht denn dagegen sich Montag nach oder zwischen dem Unterricht, in der Mittagspause, wie auch immer, sich ins Labor zu setzen und das auszuprobieren? Bei uns sind alle Räume immer offen, ist das bei euch nicht der Fall, müßt ihr eben den zuständigen Mitarbeiter fragen. Blockt er ab oder wird sogar pampig, dann würde ich die Schule wechseln. Ist ja keine duale Ausbildung, wo du in irgendeiner Form gebunden wärst.

Ja das mit RR A weiss ich ja das in einer Schleife er sich immer weiter bewegt. Aber er soll sich diesmal ja nur 100 Schritte nach rechts bewegen. Mach ich also einfach 100 mal RR A?

Bei 100 mal RR A hast du 3 Möglichkeiten:
1. 8 mal RR A und du hast den gleichen Wert wie vorher. Das heißt 4 mal RR A und du hast den gleichen Wert wie bei 100 mal RR A. Mußt du die Daten nicht nach jedem Rotieren auswerten, ist das wohl die beste Möglichkeit.
2. tatsächlich 100 mal RR A in den Programmcode schreiben. Das sieht häßlich aus und sind 100 Byte Programmspeicher (ein Vielfaches mehr noch, wenn du sie jedes mal auswerten mußt). Also nur empfohlen, wenn wirklich jede tausendstel Sekunde zählt und du nirgendwo anders optimieren kannst. In der Regel die Finger von sowas lassen.
3. Eine Schleife:

mov R4,#100
loop:
  rr a
  ;sonstige Auswertungen
  djnz R4,loop
;end loop

Also du schreibst ja das:

Initialisierung:
  RegisterX := 0
Endlosschleife:
  Führe Messung durch
  Wenn RegisterX < ADDAT:
    Motor Vor
    Erhöhe RegisterX
  Wenn RegisterX > ADDAT:
    Motor Zurück
    Verringer RegisterX
Ende Endlosschleife

Was bedeutet dieser ":" ?
Und was heißt RegisterX?

Naja also was ich jetzt weiss:
Bei Motor vor kommt das dann rein

mov R4,#255
Anfang:
  rr a
  djnz R4,Anfang
ret

Bei Motor zurück:

mov R4,#100
Anfang:
  rl a
  djnz R4,Anfang
ret

Ja jetzt fehlt mir noch
Führe Messung durch
Erhöhe Register
Verringer Register

*seufz*
Achja und bedeutet

Wenn RegisterX > ADDAT:

Das hier:

R4 >Addat

?

Nagila Hawa

Mal ehrlich: Wie viel Zeit hast du dir übers Wochenende genommen um dich zu informieren?

"A" ist ein spezielles Register, der Akkumulator. Welcher Motor, oder überhaupt welches Bauteil, reagiert auf die Veränderung eines Prozessorinternen Registers? Wie soll das denn gehen? Du mußt schon etwas an die Ein-/Ausgabe Ports senden, wenn du etwas ansteuern willst.

Zudem gehe ich nicht davon aus, daß dein Schrittmotor 100 Impulse benötigt um sich einen Schritt vor zu bewegen und dann vor allem 255 um sich einen zurück zu bewegen.

":=" steht für eine Zuweisung in einigen Programmiersprachen und soll auch hier die Zuweisung der Konstanten "0" an ein beliebiges Register sein.

erhöhe Register ist z.B. inc r4 für Register4, verringer dementsprechend dec r4.

Hast du jemals den Operator ">" in rigendeiner deiner Befehlslisten gesehen? Man sollte nicht anfangen zu raten, wie ein Befehl "eventuell aussehen könnte". Das gute, alte "IF" gibt es leider nicht direkt (habe ich jedoch in einem anderen Assembler für den 8051 mal gesehen...).

Überlege aber mal, was folgender Code bewirken könnte:

mov a,r4
  cjne a,addat,compare
  jmp loop
compare:
  jc vor
  jnc zurueck
vor:
  call motor_vor
  inc r4
  jmp loop
zurueck:
  call motor_zurueck
  dec r4
  jmp loop

Zu führe Messung durch habe ich dich mal gebeten dir das ADCON-Register anzuschauen...

Verdammt ich schaff es wohl nicht:
Hier ist das richtig als Messung

Ich weiss nicht wie ich das vergleiche

Aber ist das richtig das dein Programm oben das Hauptprogramm ist?
Hab jetzt eben so Hauptprogramm:

$IC(sfr.def)
Org 5000H

CALL ADW62

loop:
mov a,r4
  cjne a,addat,Anfang
  jmp loop
Anfang:
  jc vor
  jnc zurueck
vor:
  call MOTORVOR
  inc r4
  jmp loop
zurueck:
  call MOTORZURUECK
  dec r4
  jmp loop

$IC(MOTORZURUECK.DEF)
$IC(ADW62.DEF)
$IC(MOTORVOR.DEF)

End

ADW:

ADW62:

clr MX0 
Setb MX1
CLR MX2

Setb adm
jb BSY,$
ret

Motorvor:

MOTORVOR:

mov R4,#100
Anfang:
  rr a
  djnz R4,Anfang
ret

Motorzurueck

MOTORZURUECK:

mov R4,#100
Anfang:
  rl a
  djnz R4,Anfang
ret

Bei Messen hab ich das:

mov addat,#255
mov a,#255
subb a,addat

Verdammt wir müssen heute fertig werden scheisse man ich muss es chaffen

Na gut das wars, noch 20 Minuten. Naja trotzdem danke...

Da es jetzt eh vorbei ist (-.-), könnte mir jemand freundlicherweise schreiben wie ich es hätte machen müssen? Also der fertigen Code?

Nagila Hawa

Bist du dir sicher, daß du das nicht selbst herausfinden willst? Du hängst doch ohnehin schon dem Stoff hinterher. Wie es auf deinem Controller mit deinem Schrittmotor und deinem Sensor genau aussehen muß, kann ich natürlich nicht sagen. Zudem ist auch der Code natürlich ohne Gewähr, da ich keine Lust habe das Ding aufzubauen und zu testen oder großartig durchzugehen. Zum Verstehen sollte es aber auf jeden Fall ausreichen.

$processor(80537)

org 8000h
jmp start

org 8100h
start:
  mov p1,#00h
  mov r0,#00h
  mov ie0,#00h
  mov adcon,#00h

loop:
  mov dapr,#00h
  jb bsy,$

  mov a,r0
  cjne a,addat,compare
  jmp loop
compare:
  jc vor
  jnc zurueck
vor:
  call motor_vor
  inc r0
  jmp loop
zurueck:
  call motor_zurueck
  dec r0
  jmp loop

motor_vor:
  call warte
  cpl p1.0
  call warte
  cpl p1.1
  call warte
  cpl p1.0
  call warte
  cpl p1.1
  ret

motor_zurueck:
  call warte
  cpl p1.1
  call warte
  cpl p1.0
  call warte
  cpl p1.1
  call warte
  cpl p1.0
  ret

warte:	
  mov r1,#15h
warte_m1:
  mov r2,#0ffh
  djnz r2,$
  djnz r1,warte_m1
  ret

end

Hm ne geht leider nicht.