Programmierproblem Assembler
lima-city → Forum → Programmiersprachen → Sonstige Programmiersprachen
addieren
addition
adresse
assembler
befehl
bit
byte
code
dank
http
idee
lade
laden
modul
pointer
register
speichern
url
zeile
zuweisung
-
Hallo Leute
ich habe ein kleines Problem und zwar muss ich in Assembler einen Temperatursensor Programmieren.
Meine Idee war es den Wert des Sensors einzulesen. Ein 2 byte Pointer enthält die Look-up-table mit allen Werten. Der Pointer wird um den ADC_Wert erhöht und zeigt auf den Temperaturwert. Leider gibt es mir irgendwelche Zahlen zwischen 0-255 aus. Die LCD Routine funktioniert, nur die Look-up-table wird glaube ich nicht richtig eingelesen.Ich finde den Fehler einfach nicht. Ich hoffe jemand kann mir helfen.
Mein Code lautet bis jetzt wie folgt:
___________________________________________________________________________________
Temperatur_1 ldhx Pointer_Temp ; Pointer auf dem meine Look_up_Table gespeichert ist lda 0,X ; Erstes Byte des Pointers (Pointer = 2Byte) add ADC_Wert_PB0 ; Erhöht um ADC_Wert von PortB 0 ;tax sthx Pointer_Temp ; Speichert neuen Wert auf Pointer Temp lda 1,X ; Lade 2tes Byte vom Pointer add ADC_Wert_PB0 ; erhöhe um ADC_Wert von PortB 0 ;tax sthx Pointer_Temp+1T ; Speicher auf 2tes Byte vom Pointer Ausgabe_Temp ldhx #Text ; Diese Zeilen kopieren einfach den "Start-Text" sthx SourcePointer ; in das LCD-Buffer in der RAM ldhx #LCD_Oben sthx DestPointer lda #32T ; Insgesamt 32 Zeichen (2 Zeilen á 16 Zeichen) sta TextLenght jsr CopyText ldhx Pointer_Temp lda 0,x ldhx #LCD_Unten;+10T ;Schreibe Wert an Stelle 10 des Displays sthx DestPointer jsr DezimalBCD ldhx Pointer_Temp lda 1,x ldhx #LCD_Unten+12T sthx DestPointer jsr DezimalBCD Laden ; Lade Look_up_Table auf Pointer ldhx #Ausgabe_Temp_Muster sthx Pointer_Temp rts Text dc.b 'Temperatur: , C' dc.b ' '
-
Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!
lima-city: Gratis werbefreier Webspace für deine eigene Homepage
-
Assembler ≠ Assembler, du wirst also sagen müssen welchen Prozessor / Microcontroller du verwendest, falls du wirklich Hilfe bekommen möchtest.
-
Hallo,
wenn du einen 2-byte-Pointer hast - irgendwo anders war das so - musst du das lowbyte und das highbyte andersherum reinladen?!
Nur so eine Idee am Rande. -
mathesoft schrieb:
Hallo,
wenn du einen 2-byte-Pointer hast - irgendwo anders war das so - musst du das lowbyte und das highbyte andersherum reinladen?!
Nur so eine Idee am Rande.
Letztes Jahr in der Schule haben wir ebenfalls mit einem Pointer ein Lauflicht bzw. 2 Lauflichter ausgegeben und der code war wie folgt:
Cool_Blinklicht lda Counter ;Realtime_Zeitverzögerung add #1T sta Counter cmpa #DELAY bne Exit_Lauflicht lda #0T sta Counter ldhx Pointer ;Lädt Muster auf Lauflicht lda 0,X ;Pointer für PORTD auf Position 0 sta PORTD lda 1,X ;Pointer für PORTD auf Position 0 sta PORTF aix #2T ;add immediate Value -> zählt 2 weiter bei Pointer (da 2ausgaben sind) sthx Pointer cphx #Muster_Fertig beq Laden Exit_Lauflicht rts ;Zurück zum Hauptloop Laden ldhx #Muster ;Speicher Muster im Pointer sthx Pointer rts
Ps. Dieses Programm hat Funktioniert
Beitrag zuletzt geändert: 18.3.2013 0:22:04 von seppelin -
seppelin schrieb:
Mein Code lautet bis jetzt wie folgt:
___________________________________________________________________________________
Temperatur_1 ldhx Pointer_Temp ; Pointer auf dem meine Look_up_Table gespeichert ist lda 0,X ; Erstes Byte des Pointers (Pointer = 2Byte) add ADC_Wert_PB0 ; Erhöht um ADC_Wert von PortB 0 ;tax sthx Pointer_Temp ; Speichert neuen Wert auf Pointer Temp lda 1,X ; Lade 2tes Byte vom Pointer
ich meine, wenn du es so rum probierst:
Temperatur_1 ldhx Pointer_Temp ; Pointer auf dem meine Look_up_Table gespeichert ist lda 1,X ; Erstes Byte des Pointers (Pointer = 2Byte) ;tax sthx Pointer_Temp ; Speichert neuen Wert auf Pointer Temp lda 0,X ; Lade 2tes Byte vom Pointer add ADC_Wert_PB0 ; Erhöht um ADC_Wert von PortB 0
Oder aber...
sthx Pointer_Temp+1T
ist das STHX nicht schon eine 16-Bit-Zuweisung (also 2Byte)? Was macht da dann das +1T ?
oder heißt das "Store High eXtended", gibts auch ein "Store Low eXtended" STLX.
Ich kenn den Prozessor nicht, aber gewisse Ähnlichkeiten sind schon da zu den 80x86.
Vielleicht schreibe ich auch nur Müll
-
ist das STHX nicht schon eine 16-Bit-Zuweisung (also 2Byte)? Was macht da dann das +1T ?
oder heißt das "Store High eXtended", gibts auch ein "Store Low eXtended" STLX.
sthx ist eine 2Byte Zuweisung, das +1T sollte nur dazu dienen das der 1Byte große Wert auf das 2te Byte geschrieben wird. Somit ist das erste Byte meine ganzzahliger Temperaturwert (zB. 25°C) und das 2te Byte für die Nachkommazahlen (zB. ...,5°C)
sthx= Store H:X (2Byte Zuweisung ins hx-Register)
sta=Store Accumulator in Memory (1Byte Zuweisung ins a-Register)
Das vertauschen hat nichts geholfen, aber danke für die schnelle Antwort -
Hallo seppelin,
so ganz verstehe ich den Code noch nicht. Ich würde als naheliegenstes mal fogendes versuchen:
Allerdings kenne ich jetzt die MCU nicht und das Datenblatt ist auch nicht sehr ausführlich, was die Befehle angeht. Ich bin davon Ausgegangen, dass Pointer_Temp ein Lable bzw. eine Adresse darstellt und ADC_Wert_PB0 ein 8-Bit Wert ist. Nachdem ich jetzt aber nicht weis, wie deine Lookup-Table aussieht erschließt sich mir nicht, inwiefern das Addieren des ADC-High-Bytes sowohl zum niederwertigen als auch zum höherwertigen Byte ein sinnvolles Ergebnis liefern soll. Ich vermute jetzt einfach mal, das Du eigentlich eher eine Addition mit Übertrag (with Carry) benötigst um den Zeiger auf die Lookup-Table korrekt zu erhöhen.ldhx Pointer_Temp ; Lade (Pointer_Temp:Pointer_Temp+1) -> H:X lda 0, X ; Lade H:X[0] -> A add ADC_Wert_PB0 ; Addiere PB0 zu A sta 0, X ; Speichere A -> H:X[0] lda 1, X ; Lade H:X[1] -> A add ADC_Wert_PB0 ; Addiere PB0 zu A sta 1, X ; Speichere A -> H:X[1] sthx Pointer_Temp ; Speichere H:X -> (Pointer_Temp:Pointer_Temp+1)
Desweiteren sieht es so aus, als ob Du ständig den Zeiger erhöhst, d.h. Du summierst die ADC-Werte immer weiter auf, was eigentlich irgenwann zu einem Überlauf führen müsste.
Ich vermute weiter, dass Du eigentlich sowas haben willst:
<Zeiger auf Text> = <Basisadresse>+<ADC-Wert>
Dann könnte es vielleicht so aussehen:
Das ist jetzt unter der Annahme, dass lda 0,X das niederwertige Byte lädt, ansonsten musst Du erst lda 1,X und als zweites lda 0,X schreiben. Desweiteren darf das Carry-Flag durch die Lade und Speicher Befehle nicht geändert werden, sonst funktioniert es nicht.ldhx lookup_base ; Lade Basisadresse der LUT -> H:X lda 0, X ; Lade H:X[0] -> A add ADC_Wert_PB0 ; Addiere PB0 zu A sta 0, X ; Speichere A -> H:X[0] lda 1, X ; Lade H:X[1] adc #0T ; Addiere Übertrag zu A sta 1, X ; Speichere A -> H:X[1] sthx text_address ; Speichere H:X -> Text Adresse
-
Danke darkpandemic
Es stimmt, der ADC hat einen 8-Bit Wert. Im Pointer habe ich die Werte der LUT gespeichert.
Ausgabe_Temp_Muster dc.b 10,0 dc.b 9,9 dc.b 9,8 dc.b 9,7 dc.b 9,6 dc.b 9,5 dc.b 9,4 dc.b 9,3 dc.b 9,2 dc.b 9,1 dc.b 9,0 dc.b 8,9 dc.b 7,2 dc.b 6,9 dc.b 6,7 dc.b 6,5 dc.b 6,2 dc.b 6,0 dc.b 5,8 dc.b 5,5 dc.b 5,3 dc.b 5,1 dc.b 4,8 dc.b 4,6 dc.b 4,4 dc.b 4,1 dc.b 3,9 dc.b 3,6 dc.b 3,4 dc.b 3,2 dc.b 2,9 dc.b 2,7 dc.b 2,5 dc.b 2,2 dc.b 2,0 dc.b 1,8 dc.b 1,5 dc.b 1,3 dc.b 1,1 dc.b 0,8 dc.b 0,6 dc.b 0,4 dc.b 0,1 dc.b 0,1 dc.b 0,4 dc.b 0,6 dc.b 0,8 dc.b 1,1 dc.b 1,3 dc.b 1,5 dc.b 1,8 dc.b 2,0 dc.b 2,2 dc.b 2,5 dc.b 2,7 dc.b 2,9 dc.b 3,2 dc.b 3,4 dc.b 3,6 dc.b 3,9 dc.b 4,1 dc.b 4,4 dc.b 4,6 dc.b 4,8 dc.b 5,1 dc.b 5,3 dc.b 5,5 dc.b 5,8 dc.b 6,0 dc.b 6,2 dc.b 6,5 dc.b 6,7 dc.b 6,9 dc.b 7,2 dc.b 7,4 dc.b 7,6 dc.b 7,9 dc.b 8,1 dc.b 8,4 dc.b 8,6 dc.b 8,8 dc.b 9,1 dc.b 9,3 dc.b 9,5 dc.b 9,8 dc.b 10,0 dc.b 10,2 dc.b 10,5 dc.b 10,7 dc.b 10,9 dc.b 11,2 dc.b 11,4 dc.b 11,6 dc.b 11,9 dc.b 12,1 dc.b 12,4 dc.b 12,6 dc.b 12,8 dc.b 13,1 dc.b 13,3 dc.b 13,5 dc.b 13,8 dc.b 14,0 dc.b 14,2 dc.b 14,5 dc.b 14,7 dc.b 14,9 dc.b 15,2 dc.b 15,4 dc.b 15,6 dc.b 15,9 dc.b 16,1 dc.b 16,4 dc.b 16,6 dc.b 16,8 dc.b 17,1 dc.b 17,3 dc.b 17,5 dc.b 17,8 dc.b 18,0 dc.b 18,2 dc.b 18,5 dc.b 18,7 dc.b 18,9 dc.b 19,2 dc.b 19,4 dc.b 19,6 dc.b 19,9 dc.b 20,1 dc.b 20,4 dc.b 20,6 dc.b 20,8 dc.b 21,1 dc.b 21,3 dc.b 21,5 dc.b 21,8 dc.b 22,0 dc.b 22,2 dc.b 22,5 dc.b 22,7 dc.b 22,9 dc.b 23,2 dc.b 23,4 dc.b 23,6 dc.b 23,9 dc.b 24,1 dc.b 24,4 dc.b 24,6 dc.b 24,8 dc.b 25,1 dc.b 25,3 dc.b 25,5 dc.b 25,8 dc.b 26,0 dc.b 26,2 dc.b 26,5 dc.b 26,7 dc.b 26,9 dc.b 27,2 dc.b 27,4 dc.b 27,6 dc.b 27,9 dc.b 28,1 dc.b 28,4 dc.b 28,6 dc.b 28,8 dc.b 29,1 dc.b 29,3 dc.b 29,5 dc.b 29,8 dc.b 30,0 dc.b 30,2 dc.b 30,5 dc.b 30,7 dc.b 30,9 dc.b 31,2 dc.b 31,4 dc.b 31,6 dc.b 31,9 dc.b 32,1 dc.b 32,4 dc.b 32,6 dc.b 32,8 dc.b 33,1 dc.b 33,3 dc.b 33,5 dc.b 33,8 dc.b 34,0 dc.b 34,2 dc.b 34,5 dc.b 34,7 dc.b 34,9 dc.b 35,2 dc.b 35,4 dc.b 35,6 dc.b 35,9 dc.b 36,1 dc.b 36,4 dc.b 36,6 dc.b 36,8 dc.b 37,1 dc.b 37,3 dc.b 37,5 dc.b 37,8 dc.b 38,0 dc.b 38,2 dc.b 38,5 dc.b 38,7 dc.b 38,9 dc.b 39,2 dc.b 39,4 dc.b 39,6 dc.b 39,9 dc.b 40,1 dc.b 40,4 dc.b 40,6 dc.b 40,8 dc.b 41,1 dc.b 41,3 dc.b 41,5 dc.b 41,8 dc.b 42,0 dc.b 42,2 dc.b 42,5 dc.b 42,7 dc.b 42,9 dc.b 43,2 dc.b 43,4 dc.b 43,6 dc.b 43,9 dc.b 44,1 dc.b 44,4 dc.b 44,6 dc.b 44,8 dc.b 45,1 dc.b 45,3 dc.b 45,5 dc.b 45,8 dc.b 46,0 dc.b 46,2 dc.b 46,5 dc.b 46,7 dc.b 46,9 dc.b 47,2 dc.b 47,4 dc.b 47,6 dc.b 47,9 dc.b 48,1 dc.b 48,4 dc.b 48,6 dc.b 48,8 dc.b 49,1 dc.b 49,3 dc.b 49,5 dc.b 49,8 dc.b 50,0 Muster_Fertig
Der Temperaturbereich liegt zwischen -10 bis 50 °C, das minus Vorzeichen muss ich noch Programmieren (also das es von -10 bis 0°C anzeigt)
Ich habe eben versucht das 1te Byte des Pointers für die ersten 2 zahlen zu verwenden und das 2te Byte des Pointers für die Nachkommastellen.
Da der ADC_Wert relativ Konstant bleibt kann ich mit einem ADC_Wert beide Werte getrennt (auch wenn sie am Ende ein Ergebnis ergeben) ausgeben.
Danke das Ihr so schnell Antwortet, ich hoffe meine Idee ist verständlicher. -
Hallo seppelin,
dann ist es eher Lösungsansatz Nummer 2. Allerdings hat eine Speicherstelle bei Dir 2 Byte, weshalb man den ADC Wert mit 2 Multiplizieren müsste. Also gilt:
<Adresse des Zahlenpaares> = <Basisadresse> + 2 * <ADC Wert>
Nachdem die Multiplikation das X Register verwendet, in welchem wir die Basisaddresse haben, und der Akkumulator nur 8-Bit groß ist schreiben wir das lieber zu:
<Adresse des Zahlenpaares> = <Basisadresse> + <ADC Wert> + <ADC Wert>
um
Könnte dann in etwa so aussehen:
Allerdings bin ich mir jetzt nicht ganz sicher, ob ich die Befehle ldhx, sthx und vor allem das lda *, X bzw. sta *,X richtig interpretiere. Aber ich hoffe die Grundidee ist klar.ldhx Ausgabe_Temp_Muster ; Lade Basisadresse -> H:X ; 1. Addition: lda 0, X ; Lade H:X[0] -> A add ADC_Wert_PB0 ; Addiere PB0 zu A sta 0, X ; Speichere A -> H:X[0] lda 1, X ; Lade H:X[1] -> A adc #0T ; Addiere Überhang sta 1, X ; Speichere A -> H:X[1] ; 2. Addition: lda 0, X ; Lade H:X[0] -> A add ADC_Wert_PB0 ; Addiere PB0 zu A sta 0, X ; Speichere A -> H:X[0] lda 1, X ; Lade H:X[1] -> A adc #0T ; Addiere Überhang sta 1, X ; Speichere A -> H:X[1] sthx Pointer_Temp ; Speichere H:X -> (Pointer_Temp:Pointer_Temp+1)
Edit: Falsch kopiert.
Beitrag zuletzt geändert: 18.3.2013 22:25:54 von darkpandemic -
Derzeit wird 255,255 ausgegeben egal welchen ADC_Wert vorhanden ist. Ich verstehe nur nicht wieso es 2 Additionen benötigt und diese gleich aussehen.
-
seppelin schrieb:
Derzeit wird 255,255 ausgegeben egal welchen ADC_Wert vorhanden ist. Ich verstehe nur nicht wieso es 2 Additionen benötigt und diese gleich aussehen.
Hm.. der Messfühler ist aber nicht kaputt / falsch gepolt? Bzw. du liest den korrekten Port aus? Nur so ein anderer Gedanke.. -
Also ich hab den Sensor noch nicht angeschlossn. Habe meinen Sensor von 0-5V angepasst und änder den Wert über einen Trimmer. Allerdings Funktioniert es auch nicht wenn ich stat den ADC-Wert irgend welche Zahlen dazu zähle.
Das ist eben ein Teil meiner Abschlussarbeit und ich komme einfach nicht weiter! -
Hallo seppelin,
zuerst zur Frage, warum man den ADC-Wert mit Zwei multiplizieren muss:
Dazu muss man sich anschauen, wie Deine Wertetabelle im Speicher abgelegt ist.
Der Ausdruck dc.b sagt dem Assembler, dass er es hier mit Byte-Werten zu tun bekommt. Danach kannst Du entweder eine einzelne Zahl oder eine durch Kommas getrennte Liste von Zahlen angeben, welche im Speicher der Reihe nach als 1-Byte große Werte abgelegt werden. Wenn danach eine neue Zeile mit einem weiteren dc.b kommt, dann werden diese Werte einfach dahinter abgelegt. Die ersten fünf Einträge Deiner Lookup-Table erzeugen daher folgende Byte-Reihenfolge im Speicher:
Hierbei ist steht unter Offset der Abstand zur Basisadresse, unter Wert der Wert des Bytes an der Adresse <Basisadresse> + <Offset> und Type gibt an, ob es sich um den Ganzzahlanteil (G) oder den Nachkommaanteil (N) handelt.+------+---+---+---+---+---+---+---+---+---+---+ |Offset| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| +------+---+---+---+---+---+---+---+---+---+---+ |Wert | 10| 0| 9| 9| 9| 8| 9| 7| 9| 6| +------+---+---+---+---+---+---+---+---+---+---+ |Type | G| N| G| N| G| N| G| N| G| N| +------+---+---+---+---+---+---+---+---+---+---+ ^ | Basisadresse = #Ausgabe_Temp_Muster
Wenn der ADC-Wert z.B. 3 ist, dann willst Du als Ausgabe ja den Wert 9.7 erzeugen. Wenn Du jetzt in obige Tabelle schaust, dann siehst Du, dass der zugehörige Ganzzahlanteil bei Offset 6 und der Nachkommastellenanteil bei Offset 7 zu finden ist, weil ja jedes Zahlenpaar 2 Byte im Speicher belegt.
Daher gilt:
<Adresse Ganzzahlanteil> = <Basisadresse> + 2 * <ADC-Wert>
und
<Adresse Nachkommastelle> = <Basisadresse> + 2 * <ADC-Wert> + 1
Und jetzt zurück zum Code:
Ich habe noch ein bisschen herumgesucht und dabei hat sich mein ungutes Gefühl bestätigt
Man muss hier wohl Syntaktisch sehr aufpassen, wann man es mit einer Adresse und wann mit dem eigentlichen Wert zu tun hat.
Soweit ich es verstanden habe würde z.B. folgendes:
die ersten beiden Bytes aus der Lookup-Table in das Registerpaar H:X laden. Um die Basisadresse zu laden hätte manldhx Ausgabe_Temp_Muster
schreiben müssen. Also war die erste Zeile schon einmal Quatsch.ldhx #Ausgabe_Temp_Muster
Die Idee wäre ja gewesen die Basisadresse nach H:X zu laden und dann den 8-Bit ADC-Wert dazu zu addieren. Die Zeile
lädt aber nicht das X-Register in den Akkumulator sondern das Byte, das im Speicher an der Position H:X+0 steht. Also nicht das was man eigentlich will. Im Datasheet habe ich gesehen, dass es die Befehle tax und txa gibt mit denen man zumindest das X-Register in den Akkumulator kopieren und den Akkumulator wieder in das X-Register befördern kann. Leider gibt es sowas für das H-Register nicht. Also wenn man sowas wielda 0, X
bzw.mov A, H
nicht schreiben kann, dann führt der Weg über das H:X Register nicht zum Ziel und man muss stattdessen über den Speicher gehen.mov H, A
Also der nächste Versuch, der vielleicht nicht mehr ganz so falsch ist:
Variable für die berechnete Adresse:
Der (vielleicht etwas richtigere) Code:LUT_POINTER ds.w 1
Hierbei wurde wieder angenommen, dass die Adresse Little-Endian ist. Ansonsten muss beim Addieren erst das erste und danach das nullte Byte geladen werden.ldhx #Ausgabe_Temp_Muster ; Lade Basisadresse -> H:X sthx LUT_POINTER ; Speichere Basisadresse -> LUT_POINTER ldhx #LUT_POINTER ; Lade Adresse von LUT_POINTER -> H:X ; 1. Addition: lda 0, X ; Lade LUT_POINTR[0] -> A add ADC_Wert_PB0 ; Addiere PB0 zu A sta 0, X ; Speichere A -> LUT_POINTER[0] lda 1, X ; Lade LUT_POINTER[1] -> A adc #0 ; Addiere Überhang sta 1, X ; Speichere A -> LUT_POINTER[1] ; 2. Addition: lda 0, X ; Lade LUT_POINTR[0] -> A add ADC_Wert_PB0 ; Addiere PB0 zu A sta 0, X ; Speichere A -> LUT_POINTER[0] lda 1, X ; Lade LUT_POINTER[1] -> A adc #0 ; Addiere Überhang sta 1, X ; Speichere A -> LUT_POINTER[1] ldhx LUT_POINTER ; Lade berechnete Adresse -> H:X lda 0, X ; Ganzzahlanteil -> A lda 1, X ; Nachkommaanteil -> A
Edit: Variablendeklaration korrigiert.
Beitrag zuletzt geändert: 19.3.2013 21:33:52 von darkpandemic -
Danke für die Versuche darkpandemic, es funktioniert auf dese Weise immer noch nicht. Allerdings habe ich es auf eine andere Weise gelöst. Ich habe 2 LUT verwendet (eine für die Ganzzahlen und eine für die Nachkommazahlen)
Jetzt muss ich nur noch das Problem mit dem Vorzeichenwechsel lösen
-
Hallo seppelin,
freut mich, dass es mit 2 LUTs funktioniert (spart Dir die 16-Bit Addition).
Aber rein aus Neugirde, hast Du es auch mit umgekehrter Reihenfolge der Bytes beim Addieren versucht?
Also zwei mal:
lda 1, X ; Lade LUT_POINTR[1] -> A add ADC_Wert_PB0 ; Addiere PB0 zu A sta 1, X ; Speichere A -> LUT_POINTER[1] lda 0, X ; Lade LUT_POINTER[0] -> A adc #0 ; Addiere Überhang sta 0, X ; Speichere A -> LUT_POINTER[0]
Und weil mir das Rumraten gerade solchen Spaß macht, noch ein (vielleicht mieser) Vorschlag:
lda ADC_Wert_PB0 ; Lade ADC-Wert -> A cmp #43 ; Vergleiche mit 43 blo ADD_SIGN ; Wenn kleiner springe zu ADD_SIGN <normale Ausgabe> ; sonst normale Ausgabe
Beitrag zuletzt geändert: 20.3.2013 22:48:23 von darkpandemic -
darkpandemic schrieb:
Aber rein aus Neugirde, hast Du es auch mit umgekehrter Reihenfolge der Bytes beim Addieren versucht?
Ja habe ich auch gemacht, allerdings könnte es auch sein das ich sonst irgend einen kleinen Fehler gemacht habe
Allerdings hat mein Lehrer gesagt die Grundidee stimmpt, aber er weiß auch nicht genau was fehlt
Und weil mir das Rumraten gerade solchen Spaß macht, noch ein (vielleicht mieser) Vorschlag:
Danke für dein Rumraten
-
Naja, wenn Dein Lehrer den Fehler auch nicht sieht, dann fühle ich mich gleich besser
-
Das ist eben eine art Abschlussarbeit. Noch das Vorzeichen Programmieren, Feuchtigkeitssensor (gleiche Routine mit anderer LUT) und
den Telit GL865 Programmieren (SMS versenden)
-
...und zuletzt das Projekt dann opensource auf www.sf.net legen, damit auch andere noch was davon haben...
Beitrag zuletzt geändert: 23.3.2013 1:33:39 von mathesoft -
Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!
lima-city: Gratis werbefreier Webspace für deine eigene Homepage
