Codeschloss programmieren

[Fibi]

Hallo zusammen....
ich befinde mich gerade in der Ausbildung zum Techniker.Dort haben wir nun die Aufgabe mit dem ATMEGA 8 ein Codeschloss zu programmieren.
Diese Aufgabe macht mir ziemliche Schwierigkeiten,da mein bisheriges Wissen ziemlich begrenzt ist...
Daher meine Frage an Euch ob ihr mit helfen könnt.....die Aufgabe soll folgende Kriterien erfüllen:
Der Ziffernblock soll nach dem 1 aus 12 Prinzip programmiert werden,also jede Taste(Schliesser) wird ein eigener Pin zugwiesen.(Pull up ?)
Der richtige Zifferncode wird eingegeben und gespeichert,während vorher ein Schalter betätigt wird.
Bei Eingabe des Codes (z.b 3 Ziffern) und der * Taste soll eine Rückmeldung über eine grüne LED (kurzes aufleuchten)erfolgen wenn der Code richtig ist.
Bei falscher Eingabe soll eine rote LED kurz aufleuchten.Bei Eingabe der # Taste wird die bisherige Eingabe gelöscht bzw abgebrochen.
Hoffe Ihr köönt mir weiterhelfen und anregungen geben wie ich die Aufgabe angehen soll/kann !?!?!

 

[Cassio]

Hallo Fibi!

Dann mal Willkommen im AVR-Praxis Forum!

Die Aufgabe klingt doch ganz interessant und realisierbar.
Welche Vorbildung in Sachen Elektronik und Programmierung hast du denn nun?
In welcher Sprache möchtest du bzw. müsst ihr denn programmieren?

Ich würde sagen..... zeichne doch deine ersten Ideen vom Schaltplan mal auf und stell ggf. deine ersten Programmierversuche gleich mit ein.

Danach kann dir dann evtl. auch ein User helfen, wenn es an irgendeiner Stelle Probleme gibt.


Grüße,
Cassio

 

[dino03]

Hi Fibi,

herzlich willkommen im Forum

Der Ziffernblock soll nach dem 1 aus 12 Prinzip programmiert werden,also jede Taste(Schliesser) wird ein eigener Pin zugwiesen.(Pull up ?)

dann sind da schon mal 12 Pins weg ... naja ... ok ...
ach ja ... und ein Pin für den Schalter und 2 Pins für die LEDs ...
macht zusammen 15 IO-Pins des Controllers. Quarz kannst du dir dabei
eigentlich sparen. Das geht auch sehr gut in der Grundeinstellung der Fuses
mit dem internen 1MHz-Takt (Werkseinstellung).

Mit den PullUps liegst du schon mal ganz richtig

Die Aufgabe ist eigentlich recht gut und einfach umzusetzen. Hört sich
komplizierter an als es ist.

Gruß
Dino

 

[Fibi]

Hallo....

Danke schonmal für eure Tips!!!
Werd mich direkt schonmal daran machen und den Schaltplan anfertigen...
@Cassio:ich soll das Codeschloss mit Bascom programmieren, diese Programmsprache ist mir neu,d.h ausser einige kleine Übungen in der Schule (z.b Lauflicht von LED's),hab ich bisher noch nie damit gearbeitet,das ist ja mein Problem!!! Aber rumheulen gibts nicht, nur Butter bei de Fische

Gruß Fibi

 

[Cassio]

.....mit Bascom programmieren, diese Programmsprache ist mir neu....

Hallo Fibi!

In welcher Sprache hast du denn vorher programmiert, oder ist das Thema AVR ganz neu für dich?

Welche Version steht dir denn zur Verfügung? Hast du eine Vollversion oder "nur" die Demo?

Wer ist denn eigentlich auf die Idee mit den zwölf Pins für die Tasten gekommen? Was für einen AVR steht euch denn zur Verfügung?

Na, dann warten wir mal gespannt auf den Schaltplan.... dann erledigen sich viele Fragen meist von allein.


Grüße,
Cassio

 

[Fibi]

Hallo Cassio

Habe vorher nur Siemens S7 programmiert,also AVR ist mir ganz neu...
Zur Verfügung steht mir die Demo Version!!!
Wer die Idee hatte mit den 12 Pins? Nun ja ,so ist die Aufgabenstellung des Lehrers( habe schon gesehn das es da besser ist eine 3*4 Matrix anzuwenden).Es steht mir das AVR Board MK2 V2.10 zur Verfügung...die Platine für mein Ziffernblock ist soweit fertig....
Die Belegung ist wie folgt zugewiesen :

Schalter S1 =D.4 / LED GRün=D.6 / LED ROT=B.0 / Taste0=B.2 / Taste 1=C.5
Taste 2=C.4 / Taste 3=C.3 / Taste 4=C.2 / Taste 5 =C.1 / Taste 6=C.0
Taste 7=D.5 / Taste 8=B.5 / Taste 9=B.4 / Taste * =B.3 /Taste # =B.1

Gruß Fibi

 

[oldmax]

Hi
Nun, wenn du deine IO's bereits festgelegt hast, dann braucht's ja nur noch Programm. Das sollte doch nicht so schlimm sein. Bascom ist zar nicht n´mein Ding, aber ich versuchs mal mit der normalen Vorgehensweise:
Zeiche- oder Ziffernfolge festlegen. BSPW. bei der INitialisierung durch Default. Eine String-Variable definieren. Den Tasten Zeichen zuordnen:
Ausgangsposition:
Stringvariable ist anfangs leer. Leerstring ist sowas "". Erstes Zeichen kommt und String wird das zugeordnete Zeichen zuaddiert:
String=String+Zeichen. Danach Vergleich der Anzahl Zeichen beginnend von Vorn. Anzahl der Zeichen bekommst du aus der Abfrage, wie lang dein zusammengebastelter String ist. Ich glaube die Funktion heißt "Len" oder "Lenght$". Schau einfach in die Hilfe. Nun kopierst du soviel Zeichen aus deinem Defaultstring und vergleichst. Solange nicht der komplette Defaultstring eingelesen ist und keine Unstimmigkeit vorliegt, machst du so weiter, d. H. Taste auswerten und entsprechend behandeln. Ist eine Ungleichheit erkannt, kannst du gleich die Rote Karte zeigen und die Tastatur für weitere Zahlen sperren. Nur "Reset" läßt du zu. Also noch mal zusammengefaßt:
Defaultstring mit "Geheimzahl"
read_String mit gelesenen Tastenwerten
CopyString mit kopierter Anzahl Zeichen aus Defaultstring zum Vergleich mit read_String.
Sollte es gewsen sein....
Gruß oldmax

 

[oldmax]

Hi
Nun, wenn du deine IO's bereits festgelegt hast, dann braucht's ja nur noch Programm. Das sollte doch nicht so schlimm sein. Bascom ist zwar nicht mein Ding, aber ich versuchs mal mit der normalen Vorgehensweise:
Zeichen- oder Ziffernfolge festlegen. BSPW. bei der Initialisierung durch Default. Ein paar String-Variablen definieren. Den Tasten Zeichen zuordnen:
Ausgangsposition:
Stringvariable zur Aufnahme der Tastenwerte ist anfangs leer. Leerstring ist sowas "". Erstes Zeichen kommt und String wird das zugeordnete Zeichen zuaddiert:
String=String+Zeichen ( ASSCI- Ziffer). Danach Vergleich der Anzahl Zeichen beginnend von Vorn. Anzahl der Zeichen bekommst du aus der Abfrage, wie lang dein zusammengebastelter String ist. Ich glaube die Funktion heißt "Len" oder "Lenght$". Schau einfach in die Hilfe. Nun kopierst du soviel Zeichen aus deinem Defaultstring und vergleichst. ( Ich kenne da sowas wie Left$) Solange nicht der komplette Defaultstring eingelesen ist und keine Unstimmigkeit vorliegt, machst du so weiter, d. H. Taste auswerten und entsprechend behandeln. Ist eine Ungleichheit erkannt, kannst du gleich die Rote Karte zeigen und die Tastatur für weitere Zahlen sperren. Nur "Reset" läßt du zu. Also noch mal zusammengefaßt:
Defaultstring mit "Geheimzahl"
read_String mit gelesenen Tastenwerten
CopyString mit kopierter Anzahl Zeichen aus Defaultstring zum Vergleich mit read_String.
Sollte es gewesen sein....
Gruß oldmax

 

[Fibi]

Hi oldmax...
danke für deine Antwort, entschuldige....aber ich hab nur Bahnhof verstanden...kannst du es vlt etwas leichter für einen Anfänger beschreiben?
Danke

Gruß Fibi

 

[Cassio]

Hallo Fibi!

Eigentlich kann Oldmax sehr gut etwas erklären.....
Wenn ich allerdings Anfänger wäre, dann hätte ich seine richtige Vorgehensweise auch nicht verstanden.

Sei mir nicht böse Oldmax, aber deine durchaus richtige Beschreibung zum Aufbau des Programms setzt doch schon einige Grundkenntnisse voraus!


Da Fibi vorher "nur" S7 programmiert hat (das NUR ist NICHT abwertend gemeint !), hat er von Programmierung eine völlig andere Vorstellung.
Aus dem Grunde werden wir mit der Hilfe bestimmt viel weiter "vorne" anfangen müssen.
Warten wir aber erst mal ab wenn der Schaltplan fertig ist und Fibi`s erste Überlegungen in Sachen BASCOM-Programm hier online sind.
Danach können wir sehen, ob er auf den richtigen Weg.... oder dem Holzweg ist.

Die Ideen und Vorgaben mit dem "String" und dem LEN() ist schon OK und kann er dafür verwenden.
Auf diese Weise wird das Programm verständlich und einfacher.
Er muss lediglich schauen, dass er nicht über die 4K-Demo-Grenze kommt..... sollte aber dafür ausreichend sein.

Ist eine Ungleichheit erkannt, kannst du gleich die Rote Karte zeigen und die Tastatur für weitere Zahlen sperren.

Da stimme ich mit dir nicht überein, Oldmax!
Wenn das Codeschloss sofort auf "sturr" schaltet und die rote LED leuchtet, wenn eine falsche Taste gedrückt wird, dann verät das Codeschloss durch Ausprobieren ja selber den Code.
Von daher würde ich das lassen.

Grundsätzlich würde ich sagen, es sind 3 bis 8 stellige Eingaben möglich.....
und spätestens nach der achten Ziffer wird erst eine Fehlermeldung ausgegeben, wenn der Code falsch war.

Wenn es nun noch auf Sicherheit ankommen würde, dann müsste man noch Pausen einbauen, um ein "Austesten" zu überprüfen.
Beispiel:
Richtiger Code ist: 123
Wird nun nach der "3" innerhalb von ca. 250ms noch eine Taste gedrückt, bleibt die Eingabe des richtigen Codes unberücksichtigt.

Ich kann mir aber vorstellen, dass es bei Fibi`s Aufgabenstellung nicht auf die Sicherheit ankommt sondern es einfach nur um die Übung der Programmierung geht.


Grüße,
Cassio

 

[Fibi]

Hallo .....
@Cassio: du hast Recht , wichtig ist erst einmal das ich die Aufgabenstellung erfülle, den Sicherheitsaspeckt lassen wir bitte der einfacher halber erst einmal weg, bin ja schon froh wenn ich die Aufgabe soweit zum laufen bekomme.das soll nicht heissen das mir die Sicherheit der Eingabe nicht wichtig ist!!!
Ich habe anbei den Schaltplan hochgeladen...hoffe er ist leserlich genug!!!

MFG Fibi

 

[Cassio]

Ich habe anbei den Schaltplan hochgeladen...hoffe er ist leserlich genug!!!

Hallo Fibi!

Tut mir leid, aber ich kann nicht wirklich etwas erkennen.
Hast du keine Software dafür?

Falls nicht, dann......
scan das Bild noch mal mit einer höheren Auflösung in schwarz/weiß ein und konvertiere es anschließend zu einem GIF-Bild.


Grüße,
Cassio

 

[oldmax]

Hi
Also, S5 und nachfolgend S7 ist mein Tagesgeschäft... also es ist richtig, das es etwas anders ist, aber auch in dieser Welt werden Programmblöcke benutzt. Man nennt sie nur FB's und FC's. Auch OB's als Basis (Programmschleife, Interrupt's etc......) Vielleicht muß man ein klein wenig um die Ecke denken.
Na, und dann gibt's noch die graphischen Programmierebenen, aber wir schweifen ab..
Auch ein Anfänger tut sich was gutes an, wenn er versucht, seine Programme erst einmal im Kopf ablaufen zu lassen. Hier hilf mal ein Gedankenspiel:
Ich merke mir eine Zahl. Nun frage ich einen Freund, ob er dir diese Zahl nennen kann und ich sage ihm "falsch" oder "richtig".
Gut, das war ziemlich komplex, aber nix anderes macht BASCOM. Ob du nun erst auf alle Ziffern wartest und dann meckerst, das da was falsch ist, oder es schon ziemlich früh anzeigst, ist erst einmal Nebensache. Will ich die Villa meines Nachbarn ohne sein Wissen aufsuchen, wär es zugegebenermaßen "ungeschickt" von seiner Sicherheitsfirma, solch ein Codeschloß einzubauen, welches mir gleich sagt "du kommst hier nicht rein... "
Ok, zurück zum Thema.
Wie merkt sich ein µC eine Zahl ? Über seinen Speicher. Und damit er weiß, wo diese Zahl steht, muß er einen Zeiger auf diese Speicherstelle setzen. Da wir aber nicht mit solchen Zeigern in Hex-Code umgehen können, haben findige Menschen das Wort "Variable" erfunden. Der Vermittler zwischen Mensch und µC ist BASCOM. Wenn wir sagen: die Variable "Geheimzahl" ist ein String, so wird dem Controller klargemacht, das er ab einer Adresse Werte eintragen kann. In diesem Fall die ASCII-Zeichen der Ziffern. So das war Schnellkurs in "Verstehen sie ihren µC ?"
Also, was habe ich im letzten Post geschrieben ?
Wir brauchen drei Variablen:
Eine für die Geheimzahl, eine für die eingegebenen Zeichen und einen, um zu vergleichen... na ja, ihr habt mich überzeugt, letztere kann entfallen. Das macht das Programm einfacher.
Also, du empfängst einen Tastendruck. Dafür bau dir ein kleines Programm, um die IO's einzulesen. Nun stellst du fest, es ist (Moment, ich muß mal nachsehen ) Bit PortC.5 betätigt. Also setzt du den Wert auf "1" und diesen Wert addierst du zum String.
Stringaddition:
Alter String=Alter String + neues Zeichen.
Der String, nennen wir ihn mal "Eingabe" baut sich nun wie folgt auf:
Eingabe = Eingabe + "1"
"" = "" + "1"
Eingabe hat jetzt den Wert "1". Nun erfolgt der nächste Tastendruck und du siehst: "aha, Bit Port C.1 ist gekommen. Nachsehen und Zeichen "5" erkennen. Nun wieder die Stringaddition
Eingabe = Eingabe + "5"
"1" = "1" + "5"
Jetzt hat Eingabe den Wert "15"
Das könnt ich jetzt beschreiben bis die Sonne wieder aufgeht, aber dazu hab ich keine Lust.. Du solltest jetzt auch erkennen, wie es funktioniert. Bekommst du ein anderes Bit zu sehen, reagierst du entsprechend. Zum Beispiel mit "Reset" oder "Übernahme", also löschen der Eingabe durch Zuweisen eines Leerstrings Eingabe ="" oder das Auslösen des Vergleiches mit "falsch" oder "richtig"-Ergebnis.
Da ich mit Bascom nicht arbeite, kann ich dir nur einen Leitfaden geben, aber eigentlich ist es in allen Programmiersprachen gleich: "du weißt was du willst, zerlege die Aufgabe in kleine Blöcke, die eine Aufgabe Schritt für Schritt abarbeiten. Dein Kopf macht es ja auch so, nur weißt du es nicht. Genauso wie du meinst, eine gemultiplexte Anzeige zeigt alle Zeichen an oder der Fernseher liefert Bilder. Du mußt nur lernen, die Zeit soweit aufzudröseln, bis du ein Pixel siehst.... In der Programmierung mußt du ebenfalls diesen Weg gehen. Klar, die Anfangs angesprochene Geheimzahl, von einem Freund zu erraten, alles ein komplexer Vorgang. Mach dir die Einzelschritte bewußt.
Das ist alles, was ein Programmierer braucht, die Gabe, etwas bis ins kleinste Detail herunter zu brechen, um es dann wieder zusammenzusetzen. So, nun genug geschwafelt....
SChönen Abend noch.
Gruß oldmax

 

[oldmax]

Hi
Also, S5 und nachfolgend S7 ist mein Tagesgeschäft... also es ist richtig, das es etwas anders ist, aber auch in dieser Welt werden Programmblöcke benutzt. Man nennt sie nur FB's und FC's. Auch OB's als Basis (Programmschleife, Interrupt's etc......) Vielleicht muß man ein klein wenig um die Ecke denken.
Na, und dann gibt's noch die graphischen Programmierebenen, aber wir schweifen ab..
Auch ein Anfänger tut sich was gutes an, wenn er versucht, seine Programme erst einmal im Kopf ablaufen zu lassen. Hier hilf mal ein Gedankenspiel:
Ich merke mir eine Zahl. Nun frage ich einen Freund, ob er dir diese Zahl nennen kann und ich sage ihm "falsch" oder "richtig".
Gut, das war ziemlich komplex, aber nix anderes macht BASCOM. Ob du nun erst auf alle Ziffern wartest und dann meckerst, das da was falsch ist, oder es schon ziemlich früh anzeigst, ist erst einmal Nebensache. Will ich die Villa meines Nachbarn ohne sein Wissen aufsuchen, wär es zugegebenermaßen "ungeschickt" von seiner Sicherheitsfirma, solch ein Codeschloß einzubauen, welches mir gleich sagt "du kommst hier nicht rein... "
Ok, zurück zum Thema.
Wie merkt sich ein µC eine Zahl ? Über seinen Speicher. Und damit er weiß, wo diese Zahl steht, muß er einen Zeiger auf diese Speicherstelle setzen. Da wir aber nicht mit solchen Zeigern in Hex-Code umgehen können, haben findige Menschen das Wort "Variable" erfunden. Der Vermittler zwischen Mensch und µC ist BASCOM. Wenn wir sagen: die Variable "Geheimzahl" ist ein String, so wird dem Controller klargemacht, das er ab einer Adresse Werte eintragen kann. In diesem Fall die ASCII-Zeichen der Ziffern. So das war Schnellkurs in "Verstehen sie ihren µC ?"
Also, was habe ich im letzten Post geschrieben ?
Wir brauchen drei Variablen:
Eine für die Geheimzahl, eine für die eingegebenen Zeichen und einen, um zu vergleichen... na ja, ihr habt mich überzeugt, letztere kann entfallen. Das macht das Programm einfacher.
Also, du empfängst einen Tastendruck. Dafür bau dir ein kleines Programm, um die IO's einzulesen. Nun stellst du fest, es ist (Moment, ich muß mal nachsehen ) Bit PortC.5 betätigt. Also setzt du den Wert auf "1" und diesen Wert addierst du zum String.
Stringaddition:
Alter String=Alter String + neues Zeichen.
Der String, nennen wir ihn mal "Eingabe" baut sich nun wie folgt auf:
Eingabe = Eingabe + "1"
"" = "" + "1"
Eingabe hat jetzt den Wert "1". Nun erfolgt der nächste Tastendruck und du siehst: "aha, Bit Port C.1 ist gekommen. Nachsehen und Zeichen "5" erkennen. Nun wieder die Stringaddition
Eingabe = Eingabe + "5"
"1" = "1" + "5"
Jetzt hat Eingabe den Wert "15"
Das könnt ich jetzt beschreiben bis die Sonne wieder aufgeht, aber dazu hab ich keine Lust.. Du solltest jetzt auch erkennen, wie es funktioniert. Bekommst du ein anderes Bit zu sehen, reagierst du entsprechend. Zum Beispiel mit "Reset" oder "Übernahme", also löschen der Eingabe durch Zuweisen eines Leerstrings Eingabe ="" oder das Auslösen des Vergleiches mit "falsch" oder "richtig"-Ergebnis.
Da ich mit Bascom nicht arbeite, kann ich dir nur einen Leitfaden geben, aber eigentlich ist es in allen Programmiersprachen gleich: "du weißt was du willst, zerlege die Aufgabe in kleine Blöcke, die eine Aufgabe Schritt für Schritt abarbeiten. Dein Kopf macht es ja auch so, nur weißt du es nicht. Genauso wie du meinst, eine gemultiplexte Anzeige zeigt alle Zeichen an oder der Fernseher liefert Bilder. Du mußt nur lernen, die Zeit soweit aufzudröseln, bis du ein Pixel siehst.... In der Programmierung mußt du ebenfalls diesen Weg gehen. Klar, die Anfangs angesprochene Geheimzahl, von einem Freund zu erraten, alles ein komplexer Vorgang. Mach dir die Einzelschritte bewußt.
Das ist alles, was ein Programmierer braucht, die Gabe, etwas bis ins kleinste Detail herunter zu brechen, um es dann wieder zusammenzusetzen. So, nun genug geschwafelt....
SChönen Abend noch.
Gruß oldmax

 

[Fibi]

Hallo.....
könnt ihr bitte mal drüber schauen ob ich so auf den richtige weg bin....finde den Fehler nicht.....vlt wisst ihr was ich falsch gemacht hab..

Gruß Fibi

Der Code lautet:

$regfile = "m8def.dat"
$sim
$crystal = 1000000
'-------------------Programmteil-----------------------

Ddrc = &B00000000
Ddrb = &B00000001
Ddrd = &B01000000

Portc = &HFF                                                'Pull ups aktivieren
Portb = &B11111110
Portd = &B10111111

Taste0 Alias Pinb.2                                         'Zuweisung
Taste1 Alias Pinc.5
Taste2 Alias Pinc.4
Taste3 Alias Pinc.3
Taste4 Alias Pinc.2
Taste5 Alias Pinc.1
Taste6 Alias Pinc.0
Taste7 Alias Pind.5
Taste8 Alias Pinb.5
Taste9 Alias Pinb.4
Taste_stern Alias Pinb.3
Taste_raute Alias Pinb.1
Taste_s1 Alias Pind.4
Led_gruen Alias Pind.6
Led_rot Alias Pinb.0

'Dim Mastercode As Byte
Dim Array(10) As Byte
Dim Array1(10) As Byte
Dim Merker As Byte
Dim I As Byte
Dim X As Byte
Declare Sub Eingabe
Declare Sub Pruefung
X = 0
'-------------------Hauptprogramm----------------------
  Do

   If Taste_s1 = 1 Then
      Call Eingabe

   End If

If Taste_s1 = 0 Then
Call Pruefung


For I = 0 To 2 Step 1

If Array(i) = Array1(i) Then
Merker = 1
Else
Merker = 0
End If
 Next

 If Merker = 1 Then
 Led_gruen = 1
 End If

 If Merker = 0 Then
 Led_rot = 1
 End If

End If

 Loop
'--------------------Unterprogramme----------------------
Sub Eingabe

Debounce Pinb.2 , 0 , Taste_0 , Sub
Debounce Pinc.5 , 0 , Taste_1 , Sub
Debounce Pinc.4 , 0 , Taste_2 , Sub
Debounce Pinc.3 , 0 , Taste_3 , Sub
Debounce Pinc.2 , 0 , Taste_4 , Sub
Debounce Pinc.1 , 0 , Taste_5 , Sub
Debounce Pinc.0 , 0 , Taste_6 , Sub
Debounce Pind.5 , 0 , Taste_7 , Sub
Debounce Pinb.5 , 0 , Taste_8 , Sub
Debounce Pinb.4 , 0 , Taste_9 , Sub


If X = 2 Then
Led_gruen = 1
X = 0
End If
End Sub

Taste_0:

Array(x) = 0
Incr X
Return

Taste_1:

Array(x) = 1
Incr X

Return

Taste_2:

Array(x) = 2
Incr X


Return

Taste_3:

Array(x) = 3
Incr X

Return

Taste_4:

Array(x) = 4
Incr X

Return

Taste_5:

Array(x) = 5
Incr X

Return

Taste_6:

Array(x) = 6
Incr X

Return

Taste_7:

Array(x) = 7
Incr X


Return

Taste_8:

Array(x) = 8
Incr X
Return

      Taste_9:

      Array(x) = 9
       Incr X
      Return

Sub Pruefung
X = 0
Do

    'Tasten Debouncen
Debounce Pinb.2 , 0 , Taste_00 , Sub
Debounce Pinc.5 , 0 , Taste_01 , Sub
Debounce Pinc.4 , 0 , Taste_02 , Sub
Debounce Pinc.3 , 0 , Taste_03 , Sub
Debounce Pinc.2 , 0 , Taste_04 , Sub
Debounce Pinc.1 , 0 , Taste_05 , Sub
Debounce Pinc.0 , 0 , Taste_06 , Sub
Debounce Pind.5 , 0 , Taste_07 , Sub
Debounce Pinb.5 , 0 , Taste_08 , Sub
Debounce Pinb.4 , 0 , Taste_09 , Sub
'Debounce Pinb.1 , 0 , Taste__raute , Sub


Taste_00:
Incr X
Array1(x) = 0

Return

Taste_01:

Array1(x) = 1
Incr X

Return

Taste_02:

Array1(x) = 2
Incr X


Return

Taste_03:

Array1(x) = 3
Incr X

Return

Taste_04:

Array1(x) = 4
Incr X

Return

Taste_05:

Array1(x) = 5
Incr X

Return

Taste_06:

Array1(x) = 6
Incr X

Return

Taste_07:

Array1(x) = 7
Incr X


Return

Taste_08:

Array1(x) = 8
Incr X
Return

      Taste_09:

      Array1(x) = 9
       Incr X
      Return
Loop Until X < 4 And Taste_stern = 0 Or Taste_raute = 0
End Sub

 

[Cassio]

Hallo Fibi!

Puh.... also das Programm ist so dermaßen von schräg Hinten durch die Brust in die Zahnfüllung, da muss man sich erst mal reindenken.

Warum hast du den Rat von Oldmax nicht beherzigt und arbeitest mit String-Variablen?
Es würde das Programmieren um ein vielfaches (bis expotential ) erleichtern.

Gibt es also wichtige Gründe für die Arbeit mit den Arrays?


Grüße,
Cassio

 

[Bonze]

das mit den arrays versteh ich auch ned,
würde einfach nen string aus 3 zahlen/buchstaben bauen, und falls diese falsch sind verwerfen,
un rote lampe an,
falls diese rihtig sind grüne lampe an,.

das ist einfach sind 2 vergleiche

eingabestring = eingabestring + einagabe
if eingabestring >=3 then
if eingabestring = code then
grün an 
else
eingabestring leeren
rot an 
endif
else
print "es müssen 3 zahlen/buchstaben eingegeben werden"
endif

so stellöe ich mir die grund/billigversion davon vor,.