Flipflop

Hallo leute,
Ist es möglich, ein Flipflop in bascom zu programmieren,
so dass man nach kurzem tasterdruck eine led dauerhaft zum leuchten bringt und übrer einen weiteren taster wieder ausschalten kann?

Vielen dank!
Ich bracuhe schnelle Hilfe
Mfg

O:)

Na sicher doch.
Worin besteht dein Problem?
Pin abfragen. Wenn Eingang gesetzt, dann Ausgang setzen, bwz löschen.

ja gut, aber du musst wissen, dass ich absoluter anfänger bin in sachen microcontrollern.....
hättest du einen vorschlag, wie man so etwas in bascom schreibt?
also ich hab zwei taster.
einen zum einschalten und einen zum ausschalten.....
danke ....
mfg

Code:

---

$crystal = 1000000                                          'an deine Frequenz anpassen

$regfile = "m64def.dat"                                    'an deinen Mikrokontroller anpassen

Config Portb.1 = Input                                      'An
Config Portb.2 = Input                                      'Aus
Config Portb.3 = Output                                    'LED

Portb.1 = 1                                                'Pullup Widerstand ein
Portb.2 = 1                                                'sodass die Taster gegen Masse schalten


Do

If Pinb.1 = 0 Then                                          'wenn Taster 1 dann LED an
  Set Portb.3
End If

If Pinb.2 = 0 Then                                          'LED aus
  Reset Portb.3
End If

Nop                                                        'nix tun



Loop                                                        'zurück zum do

End

---

Vielen Dank! Du hast mir sehr weitergeholfen=)
Aber eine Frage wäre da noch...nach unzähligem rumprobieren habe ich nicht herausgefunden, ob man mehrere schleifen in einem programm einbauen kann....also z.B. so:

Do
PORTC.0 = 0
Waitms 100
PORTC.0 = 1
Waitms 100
Loop
Do
PORTC.1 = 0
Waitms 10
PORTC.1 = 1
Waitms 10
Loop
End

Das funktioniert nicht, hab ich schon oft ausprobiert...
Wie kann man so etwas sonst realisieren?

Danke!
Mfg

du kannst mehrere Befehle in eine Schleife setzen.
z.B.

Code:

---

Do
PORTC.0 = 0
Waitms 100
PORTC.0 = 1
Waitms 100
PORTC.1 = 0
Waitms 10
PORTC.1 = 1
Waitms 10
Loop
End

---

wobei die wait Anweisungen den kompletten Programmablauf bis auf Interrupts blockieren.

Hallo elektrohonk,

dein Beispiel kann so nicht funktionieren. Wenn es beim ersten "Loop" angekommen ist, wird ja wieder zum ersten "Do" gesprungen. Der Rest wird ignoriert. Du kannst aber eine Bedingung einfügen (z. B. Do...Loop until pinb.1 = 0). Dann wird an dieser Stelle die Schleife verlassen wenn die Bedingung erfüllt ist und die nächste wird abgearbeitet.

Wenn eine Schleife eine bestimmte Anzahl Durchläufe machen soll, arbeitet man nicht mit Do...Loop sondern mit For...Next.

Danke für eure vielen Antworten, nur leider hat mir das im Bezug auf meine zweite Frage, die mit den Schleifen, nicht wirklich weitergeholfen.
Ich bin auch gewillt, dass alles selber zu lernen, nur leider fällt mir das schwer, weil ich bisher noch keine richtige Lektüre, bzw. Artikel im Internet gefunden habe.
Könnt ihr mir da nicht vllt weiterhelfen, dann baruch ich auch nicht immer wegen jedem Mist zu fragen.
Am liebsten wäre mir natürlich ein Artkel im Internet, weil ich da dann sofort nachschlagen könnte...
Vielen Dank schon einmal..
MfG

elektrohonk

Hallo,

deine Frage wurde eigentlich beantwortet. Eine Schleife arbeitet die darin enthaltenen Befehle ab und springt dann wieder an den Anfang. Und das ganze läuft so lange, bis du den Strom wegnimmst oder einen Reset machst.

Eine zweite Schleife hinter der ersten kann nicht abgearbeitet werden, da die erste ja nicht verlassen wird. Darum heißt es ja Schleife. Mehrere Schleifen können nur verwendet werden, wenn du z. B. mit "Loop Until xxx" einen Ausstieg aus der ersten Schleife möglich machst.

Hi Elektrohonk,

Dir kann umso besser geholfen werden, je genauer Du beschreiben kannst, WAS der Controller denn eigentlich tun soll.
Könnte es sein, dass Du gleichzeitig ein 10Hz-Signal an Port C.0 und ein 100Hz-Signal an Port C.1 erzeugen möchtest? Dafür gäb´s auch Lösungen, aber man müsste schon wissen, was Dein Code bezwecken soll!

Im Internet könnte ich den folgenden Link empfehlen:
http://www.rowalt.de/mc/index.htm
Da gibt´s ein gutes Tutorial, und über das Buch von Roland Walter (ebenfalls dort erhältlich) hab´ ich auch den Einstieg gefunden.
Und natürlich immer fleißig alle Threads in dieem Forum lesen - soviele Antworten auf so viele interessante Fragen gibt´s sonst nirgendswo!!

Also - was soll Dein Controller denn tun (und by the way - was für´n Controller isses denn?)

Hi Sauerbruch (=cooler Name)

Also ich hab den ATMega 32 zusammen mit einem RN Controllerboard.
Eigentlich soll der Controller ein kleines, motorisiertes, ehemals ferngesteuertes Auto steuern. Ich habe das kleine Projekt mit einem Freund von mir letzten Montag ins Leben gerufen und bin leider noch absoluter Neuling in Sachen Controllerboard. Elektronisch gesehen bin ich kein Neuling mehr. Ich befasse mich schon jahrelang mit Elektronik, habe schon einige Projekte erfolgreich hinter mir gelassen und befinde mich zur Zeit in einer Lehre zum Elektroniker.
Also ich habe vier Lichtsensoren entwickelt und gebaut, die ca. 20cm vor einem Hindernis anschlagen und ein Signal an den Controller senden.
Drei Sensoren befinden sich am vorderen Teil des Fahrzeugs: Links, Rechts, Mitte. Und ein Sensor befinet sich am Heck des Wagens.
Sobald ein Signal vom Sensor in der Mitte kommt (Also Hindernis vorne) soll der Wagen ein Stück zurückfahren und dann wenden. Daher meine erste Frage, wegem dem Flipflop.
Natürlich säh es auch cool aus, wenn die ultrahellen LEDs der Sensoren ganz schnell blinken, oder der Wagen z.B. vor einem Hindernis zu Hupen anfängt. Dazu brauche ich halt eben die Möglichkeit mehrere Schelifen hintereinander einzuprogrammieren.
Ich hoffe, Du hast verstanden, was ich von Dir wissen will 8-[
Vielen Dank im Vorraus...
MfG
elektrohonk

Generell:
Gewöhnt euch eine strukturierte Programmierung an!
Dann sind schleinfen und Bedingungen übersichtlicher dargestellt.

Also alles was innerhalb einer Schleife steht wird eingerückt.
Schleifenanfang und Schleifenende sind dann besser ersichtlich.

z.B. So:

Code:

---

Do
  PORTC.0 = 0
  Waitms 100
  PORTC.0 = 1
  Waitms 100
  PORTC.1 = 0
  Waitms 10
  PORTC.1 = 1
  Waitms 10
Loop

End

---

Der Loop befehl bewirkt eine Rücksprung zu Do Zeile (ohne abbruchbedingung)

Willst Du eine Schleife haben, welche nach einer geprüften Bedingung beendet wird (der Rest nach der Schleife wir abgearbeitet) gibt es sog. While/Wend Do/until. Diese Schleifen werden zu anfang oder zu ende geprüft, wenn die Bedingung zutrifft wird die Schelife nicht mehr durchlaufen.

Anfangsgeprüfte Schelifen werden ggf. garnicht und Endegeprüfte Schelifen werden mindestens einmal durchlaufen.

Code:

---

$regfile "m32def.dat"
$crystal = 16000000                                        ' Takt Frequenz des AVR (ggf. Anpassen)

Dim X As Byte

' ----

X = 0
Print "Wert = " ; X
Rem Aufwärtszählen bis X = 10 ist
Do
  X = X + 1                                                ' um 1 erhöhen
Loop Until X >= 10                                          ' Ende geprüfte Schleife


Print "Wert = " ; X

Rem Aufwärtszählen in 10er Schritten bis X = 100 ist
While X < 100                                              ' Anfang geprüfte Schleife
  X = X + 10                                              ' um 10 ehöhen
Wend

Print "Wert = " ; X


End                                                        ' end program

---

Es gibt auch Befehle, mit welche die Schleifen frühzeitig abgebrochen werden können: EXIT DO / EXIT WHILE.

Für Dein Problem hab ich mal (astrakt) ein Beispiel:

Code:

---

$regfile "m32def.dat"
$crystal = 16000000                                        ' Takt Frequenz des AVR (ggf. Anpassen)

' blablablabla


' blablablabla



Sensor_front Alias Pinb.0                                  ' Hier die richtigen Port-Pins definieren
Sensor_rear Alias Pinb.1                                    ' "PIN" fragt einen "EINGANG" ab

Motor_left_direction Alias Portc.0                          ' "PORT" setzt/löscht einen I/O "AUSGANG"
Motor_right_direction Alias Portc.1
Moror_left_drive Alias Portc.2
Moror_right_drive Alias Portc.3
Hupe Alias Portc.4


Declare Sub Wenden()                                        ' Deklarieren des Subroutine
Declare Sub Anhalten()                                      ' Deklarieren des Subroutine
Declare Sub Fahren()                                        ' Deklarieren des Subroutine
Declare Sub Motoren_toggle()                                ' Deklarieren des Subroutine
Declare Sub Hupen()
Config Portb = Input                                        ' Ports definieren
Config Portc = Output                                      ' Ports definieren

Dim Hupe_an As Bit                                          ' Variable ob gehupt werden soll


' Definieren der Ausgänge

Set Motor_left_direction                                    ' Motor 1 vorwärts umschalten
Set Motor_right_direction                                  ' Motor 2 vorwärts umschalten

Reset Hupe_an                                              ' Nicht hupen
Call Fahren()                                              ' Los gehts

Do                                                          ' Endlosschleife damit das Programm immer wieder durchlaufen wird
  ' ich berücksichtigen nur den einen Sensor
  If Sensor_front = 1 Then                                ' Wenn der Sensor-Eingang HI dann
      Call Anhalten()             
      Call Hupen()
      Call Wenden()                                        ' Unterprogramm Wenden ausführen
  End If
Loop


End                                                        'end program

' ==============================================================================

Sub Wenden()
  ' Routine zum Wenden / Richtung ändern hier Programmieren
  ' Die Zeiten (Waitms) habe ich willkürlich gewählt
  Print "Wenden"                                          ' Just for Info

  Call Anhalten()                                          ' Motoren Stopp
  Waitms 1000                                              ' 1 Sekunde warten
  Reset Motor_left_direction                              ' Richtung für Motor 1 rückwärts umschalten
  Reset Motor_right_direction                              ' Richtung für Motor 2 rückwärts umschalten

  Call Fahren()                                            ' Fahren
  Waitms 250                                              ' 250 ms (fahren)
  Call Anhalten()                                          ' anhalten

  Set Motor_left_direction                                ' Motor 1 vorwärts umschalten
  Call Fahren()                                            ' Fahren
  Waitms 250                                              ' 250 ms
  Call Anhalten()                                          ' anhalten

  Set Motor_right_direction                                ' Motor 2 vorwärts umschalten
  Call Fahren()                                            ' fahren
  Waitms 250                                              ' 250 ms
  Call Anhalten()                                          ' anhalten


  Waitms 250                                              ' 250 ms
  Call Fahren()                                            ' fahren
End Sub

' ==============================================================================

Sub Anhalten()
  ' Routine zum anhalten (Motoren Stopp)
  Print "Stopp"                                            ' Just for Info
  Reset Moror_left_drive
  Reset Moror_right_drive
End Sub

' ==============================================================================

Sub Fahren()
  ' Routine zum fahren (Motoren Fahren)
  Print "Fahren"                                          ' Just for Info
  Set Moror_left_drive
  Set Moror_right_drive
End Sub

' ==============================================================================

Sub Motoren_toggle()
  ' Routine zum umschlten der Motoren
  ' nur als Beispiel (verwende ich hier nicht)
  Toggle Moror_left_drive                                  ' (ist der Pin Hi dann eben Low)
  Toggle Moror_right_drive                                ' (also umschalten des Staus)
End Sub

' ==============================================================================


Sub Hupen()
  Local X As Byte
  Print "TUT TUT"
  For X = 1 To 4
      Toggle Hupe
      Waitms 500
  Next X

End Sub


End                                                        'end program

---

Also zuerst hast Du im Hauptprogramm eine Endlosschleife.
Wenn jetzt der Sensor anspricht, dann wird zum Unterprogramm verzweigt.
Dieses ruft weitere Unterprogramme auf.

Sind die Unterprogramme jeweils beendet ,
springen diese wieder zurück (nach dem Aufrufpunkt).

Letztendlich wirst Du dann wieder in der Endlosschleife zurück sein und diese läuft wieder und wieder und wieder und wieder und wieder und wieder .

Du must jetzt nur noch aufpassen, dass in den Sub's nicht irgendwo weitere Endlosschleifen programmiert werden sonst hängst du dort fest und kommt nie in die Hauptschleife zurück.

Übrigens auch Abbruchbedingte Schleifen können endlos werden, wenn die Abbruchbedingung nie erreicht wird.

Alles verstanden?


Von den Interrupt's würde ich an Deiner Stelle erst mal die Finger lassen.
Wenn Du etwas mehr Erfahrung und Praxis hast dann ja.
Durch Interrups kann das ganze noch schneller reagieren,
aber auch diverse Probleme verursachen welche Du so nicht hast,
wenn alles schön nacheinander abläuft.
Ich denke aber auch dass Du so noch keine Zeitprobleme mit der Reaktion bekommen wirst. (ist ja noch einfach und überschaubar)

Zitat:

---

Elektronisch gesehen bin ich kein Neuling mehr. Ich befasse mich schon jahrelang mit Elektronik

---

So ging´s mir auch, bin seit ca. 6 Monaten mit Mikrocontrollern zu gange und maßlos fasziniert, wieviel "konventionelle" Hardware man auch schon mit vollkommen dilettantischem Anfänger-Code ersetzen kann...
Da hast Du Dir ja ganz schön was vorgenommen für den Anfang O:) Das RN Controllerboard kenne ich zwar nicht, aber so ein paar Ideen hätte ich schon (auch als Selbst-noch-Anfänger...):
Ich würde das ganze so gestalten, dass die 4 Sensoren auf 4 Eingangs-Pins gelegt werden, und gleichzeitig über Dioden (d.h. "oder"-verknüpft) auf einen Interrupt-Eingang gehen. Dann würde der µC sofort in die Interrupt-Routine springen, sobald einer der Sensoren ein Hindernis detektiert. Dort müsste dann die Abfrage erfolgen, welcher Sensor einen Impuls abgibt. Das könnte man über den Befehl "Case select" gestalten: Legst Du die Sensoren z.B. auf die Pins C.0-C.3, könnte Port C die Werte 1,2,4 oder 8 annehmen (je nachdem, welcher Sensor ein high liefert).

Hast Du denn schon mal mit Interrupts und ähnlichem rumexperimentiert? Die Hilfefunktion in Bascom verdient ihren Namen übrigens absolut, dort findest Du nicht nur alle Befehle, sondern auch gute Beispiel-Codes und Erklärungen.

Gruß,

Daniel

Hey Leute,

ich hab soeben die Hardware (also Sensoren, Motoransteuerung, Relaisansteuerung usw.) fertiggestellt. Jetzt werde ich mich voll auf das Programmieren konzentrieren können...
Und ich danke Euch vielmals für Eure Antworten, werde mich Morgen auf jeden Fall sofort damit beschäftigen und etwas rumexperimentieren mit den Denkanstößen und Tips die Ihr mir gegeben habt.
So macht das Arbeiten doch wieder Spaß...=)
Vielen Dank noch einmal an Euch alle! =D>
MfG
Peter