Einfache Schreibweise einer 5-Bit Wahrheitstabelle

[stardust19322]

Hallo Sauerbruch und
lieben vielen Dank für das Lob . Weiß ich zu schätzen ^^

Ok. Also wenn ich in Zukunft wieder einmal einen Controller mit einem anderen verbinde, brauchen die Eingänge des Slave keinen PullUp-Widerstand. Sehr gut - spart ein wenig Ressourcen ^^.

Nein, das habe ich vermutlich falsch ausgedrückt. Die Eingänge sind mit PullUp-Widerständen versehen, korrekt. Die Taster hingegen sind gegen 0V geschaltet, ziehen den Eingang also bei Betätigung gegen 0V. Wenn ich das noch recht in Erinnerung habe, bricht durch diese Art "Kurzschluss" nach dem PullUp-Widerstand der anliegende (sehr kleine) Strom am Eingangsport zusammen und fällt unter 1V - ein Low-Signal

Bei meinen ersten Versuchen, auf ein High-Signal als Eingangssignal zu setzen, was katastrophal. Der Controller machte, was er wollte, nur nicht das, was er sollte ^^.

Kann ich die internen PullUp-Widerstände eigentlich auch mit dem Befehl "PortX = &HFF" setzen?

Ich habe da noch eine Frage zu deinem Beispiel in Antwort #5:

Programmwahl = PINA        'Übernimmt das komplette Eingangsregister von PortA
Programmwahl = Programmwahl AND &B00011111  'Löscht die Bits 7...5 und lässt die Bits 4...0 unverändert

In dem für mich verständlichen Programmierdeutsch ^^ würde das jetzt so aussehen:

Programmwahl = PINA                       ' Hier werden alle Pins mit der Variable "Programmwahl" definiert (benannt)
Programmwahl = Programmwahl AND &B00011111       ' Die ersten 3 Bits sind gelöscht oder Ausgänge, während die letzten 5 als Eingänge anwählbar sind
PinA = &HFF         ' Würde die internen PullUp-Widerstände aktivieren, alternative Schreibweise wäre "PinA = 1"???

DIM Programm as Byte
Dim Programmwahl as Byte      ' Kann ich diese Variablendeklaration auch weglassen???
Do

Select Case Programmwahl
     Case &B00001 : Programm = 1
     Case &B00010 : Programm = 2
     Case &B00011 : Programm = 3
     Case &B00100 : Programm = 4
     etc.pp

Abgesehen vom Header wäre das dann auch schon das gesamte Einlese-Prozedere?


LG - Maik

- - - Aktualisiert - - -

Nachtrag: Das, was du da im Video siehst, ist die erste RGB-Steuerung, die ich selbst aufgebaut habe. Das Gehäuse aus qualitativ hochwertigsten Acyralglas (kratzfester als das überteuerte Bastlerglas aus dem Baumarkt - und günstiger noch dazu ^^) baue ich ebenfalls selbst. Da ist nix CNC oder mit Präzisionsmaschinen gemacht. Eine Dekupiersäge, eine Ständerbohrmaschine (mit der ich auch "fräse" sowie eine Bügel-Laubsäge mit 360°-Sägeblatt ^^.

Habe aber leider bei dieser Steuerung vergessen, die Kabelfernbedienung mit einem Stecker zu versehen. Das Kabel hat zwar einen Stecker, jedoch wird der fix auf die Mitte der Platine gesteckt. Für mich daheim aber vollkommen ausreichend ^^.


LG _ Maik

[Sauerbruch]

Nein, die beiden Codezeilen sind etwas anders zu verstehen.

Wenn Du in Bascom X = A schreibst, bezeichnet "X" eine Variable um die es geht, und "A" den Wert, den sie haben soll. Konkret also z.B.

Dim Zähler as Byte
Zähler = 20
Zähler = Zähler + 1

(Zähler hätte am Schluss den Wert 21.)

Da ein Byte 8 Bits hat, könnte man statt der 20 auch den Binärwert schreiben:
Zähler = &b00010100

Oder Hexadezimal:
Zähler = &h14

Du kannst einer Variablen aber nicht nur einen numerischen Wert (also eine Zahl) zuweisen, sondern auch gleich direkt den Inhalt eines Registers:
Dim Programmwahl as byte
Programmwahl = PINA

Damit nimmt die Variable Programmwahl den Wert an, der gerade im 8-bit-Register PINA steht.

Zur Erinnerung: Im Register PINA steht das Muster aus Einsen und Nullen, das an den Anschlüssen A.7 bis A.0 anliegt (vorausgesetzt sie sind per DDR-Register als Eingänge konfiguriert). Diesem Register kannst Du also nicht auf Befehlsebene einen Wert zuweisen, sondern sein Inhalt hängt ausschließlich von den Highs und Lows an den Anschlüssen ab. PINA = XYZ macht also keinen Sinn - man kann dieses Register nur auslesen, d.h. XYZ = PINA.
Liegt also z.B. an den Anschlüssen A.4, A.2 und A.0 ein High (und an den anderen ein Low), stünde im Register PINA der Wert &b00010101. Mit dem Befehl Programmwahl = PINA übernimmst Du also das "Muster" aus Highs und Lows aus dem Register PINA direkt in Deine Variable Programmwahl. Klar?

Jetzt könnte es ja aber sein, dass Du die Anschlüsse A.7, A.6 und A.5 für was ganz anderes brauchst - zu den Bits, die die Programmwahl steuern, gehören sie ja definitiv nicht. Du kannst aber nur das ganze Register PINA auf die Variable Programmwahl übertragen. Wenn also nur die Bits Programmwahl.4 bis Programmwahl.0 ausgewertet werden sollen, musst Du gegebenenfalls die höchsten 3 Bits der Variable Programmwahl auf 0 setzen. Das geht entweder einzeln:

Programmwahl.7 = 0
Programmwahl.6 = 0
Programmwahl.5 = 0

oder eben am Stück, indem Du die oberen 3 Bits mit einer 0 Und-verknüpfst (das Ergebnis einer UND-Verknüpfung mit 0 ist immer 0), und die unteren 5 Bits mit einer 1 UND-Verknüpfst (das Ergebnis ist immer die Ausgangsvariable selbst: 0 UND 1 = 0, 1 UND 1 = 1).

Kurz und gut: Programmwahl = Programmwahl AND &b00011111 setzt die obersten 3 Bits der Variable auf 0, egal was vorher drin gewesen war, während die unteren 5 Bits unverändert bleiben.

[Searcher]

Abgesehen vom Header wäre das dann auch schon das gesamte Einlese-Prozedere?

Eigentlich ja. Ich habe noch die blau gefärbten Kommentare eingefügt, die meiner Meinung nach besser passen. Für aktive Pullupwiderstände muß der Portpin als Eingang konfiguriert sein und im PORT Register das entsprechende Bit auf 1 gesetzt werden.

Programmwahl = PINA                       'Hier werden alle Pins mit der Variable "Programmwahl" definiert (benannt)
                                          'Hier wird der Zustand aller Pins von PortA in die Variable Programmwahl übertragen.
Programmwahl = Programmwahl AND &B00011111       'Die ersten 3 Bits sind gelöscht oder Ausgänge, während die letzten 5 als Eingänge anwählbar sind
                                                 'Die ersten 3, nicht zu beachtenden Bits werden auf 0 gesetzt.
PinA = &HFF         'Würde die internen PullUp-Widerstände aktivieren, alternative Schreibweise wäre "PinA = 1"???
PortA = &HFF        'Würde die internen PullUp-Widerstände aktivieren, alternative Schreibweise wäre "PortA.0 = 1 , PortA.1 = 1, ...

DIM Programm as Byte
Dim Programmwahl as Byte      'Kann ich diese Variablendeklaration auch weglassen???
                              'Nein. Wird dir der Compiler aber schon melden. Ist kein in Bascom vordefinierter String sondern eine Anwendervariable und muß vor erster Verwendung deklariert sein.
Do

Select Case Programmwahl
     Case &B00001 : Programm = 1     'Hier könnten jetzt schon Aufrufe von Unterprogrammen stehen. Das was "Programm" zugewiesen wird steht ja schon in "Programmwahl".
     Case &B00010 : Programm = 2
     Case &B00011 : Programm = 3
     Case &B00100 : Programm = 4
     etc.pp

Gruß
Searcher

[stardust19322]

Aaaah - jetzt hats Klick gemacht. Daaaaanke seeehr. Bin dir ein Bier schuldig ^^.
Mit Pin und Port hatte ich schon immer meine ganz kleinen schwierigkeiten, sobald ich aber direkt im Programm stecke, ist das weg. Weiß auch nicht - vermutlich der Unterschied zwischen Theorie und Praxisnähe, was im Kopf nen Schalter umlegt.

Klar, kein Thema. Es war nur ein Beispiel, nach jedem Case in der Select eine Variable zu definieren. Im späteren Programm rufe ich hingegen gleich die anschließend fertig geschriebenen Unterprogramme auf, mit "Call XYZ", also "Case &B00000101 : Call Sub Muster_5" ...und die dazu passende Call ^^.


Bislang bin ich nun gewappnet. Morgen muss ich wieder auf Montage, da habe ich dann abends Zeit zum Programmieren, wenn ich das nicht verschwitze. Ein Regal mit 24 Fächern soll in unterschiedlichen Modulen leuchten - habe dazu eigens ein 12V_10A Vorschaltgerät gekauft. Dauert aber halt noch etwas.

Vorteil: Das Programm auf dem ATMega8, welches die Farben ansteuert, ist im Großen und Ganzen schon fertig. Allerdings will ich noch ein Display und Cursortaster einbinden, plus eben die Auswahlmöglichkeit der unterschiedlichen Module.


Die Haupt-Steuerplatine für die ersten 12 Ports schaut dann so aus:



Zur Erläuterung: Die Pinbank rechts neben dem ATMega8 hat oben 4 Taster als Eingang, darunter Spannungsversorgung und Display-Ansteuerung.
Die Ausgänge des ATMega8 sind an den Hardware-PWM-Registern angeschlossen, OC1A, OC1B und OC2. Sie steuern die Farben und das Fading.
Die untersten Transistoren schalten die Spannungsversorgung und werden durch den ATMega8515 angesteuert.
Die Pinbänke links werden anschließend zur 2ten Platine gelegt, welche die letzten 12 Ports beinhaltet.

Finde das echt klasse und ärgere mich tierisch, dass ich das nicht schon viel früher mit dem Programmieren begonnen habe...


LG - Maik

[stardust19322]

Hallo.

@ Searcher: Das, was du als Beispiel geschrieben hast, funktioniert leider nicht. Die Eingangsports können nicht an eine Variable übergeben werden. Wenn ich die Variable entsprechend als Byte deklariere und dem Port mit "Programm = PINA" zuweise, kann ich machen was ich will - das Register reagiert nicht auf Tastenbefehle.
Schreibe ich allerdings z.B. "If PinA.0 = 0 then ...etc.pp", dann klappt alles.
Denke, dass ich die Wahrheitstabelle vielleicht so aufbaue, mit direktem Portzugriff.
Da ich keine weiteren Ports benötige, sollte das funktionieren, denke ich.
Mal probieren.


LG - Maik

[Sauerbruch]

@ Searcher: Das, was du als Beispiel geschrieben hast, funktioniert leider nicht. Die Eingangsports können nicht an eine Variable übergeben werden. Wenn ich die Variable entsprechend als Byte deklariere und dem Port mit "Programm = PINA" zuweise, kann ich machen was ich will - das Register reagiert nicht auf Tastenbefehle.

Also bei mir hat sich dieses Vorgehen sehr bewährt, und wenn die einzelnen Bits im Register PINA offensichtlich die Pegel auf den Leitungen korrekt darstellen, muss der Fehler wo anders liegen. Was hast Du denn Hardware-seitig mit den Anschlüssen A.7 bis A.5 gemacht?

Sehr hilfreich wäre es, wenn Du uns Deinen Code mal zeigen könntest. Mit so ´ner quadratmetergroßen Wahrheitstabelle statt einer einzigen (korrekten!!) Befehlszeile wirst Du doch ramdösig, oder???

[stardust19322]

Und wie ich das werden würde... ^^

Hallo Sauerbruch.

Die Wahrheitstabelle habe ich jetzt im Ganzen umgesetzt. Dabei sind alle Eingangspins benannt. Die internen PullUp's sind gesetzt, wodurch ich die nicht angeschlossenen Pins im Grunde auch in der Luft hängen lassen könnte - oder was meinst/denkst du? Würde dies vielleicht zu Fehlfunktionen führen?

Der Code sieht bislang so aus (nach meinem letzten Post geschrieben):

$regfile = "m8515.dat"
$crystal = 8000000
$hwstack = 40
$swstack = 16
$framesize = 32


'-------------------------------------------------------------------------------
'  *** Konfiguriere Ein- und Ausgangsports ***

Config Porta = Input
Config Portb = Output
Config Portc = Output
Config Portd = Output

Porta = &HFF       ' Aktiviert die internen Pullup-Widerstände
Portb = &HFF       ' schaltet alle Ausgänge 1, LED = 0
Portc = &HFF
Portd = &HFF


'-------------------------------------------------------------------------------
'  *** Konfiguriere Timer ***

Config Timer0 = Timer , Prescale = 1024
On Timer0 Isr_timer0
Enable Timer0
Timer0 = 177
Enable Interrupts


'-------------------------------------------------------------------------------
'  *** Deklarieren der Variablen ***

Dim Timercounter As Byte


'-------------------------------------------------------------------------------
'  *** Deklarieren der Subroutinen ***

Declare Sub All_off
Declare Sub All_on
Declare Sub Horizontal_lines
Declare Sub Vertical_lines
Declare Sub Straight
Declare Sub Diagonal_falling
Declare Sub Diagonal_rising
Declare Sub Net
Declare Sub Net_invert
Declare Sub Arrow_up
Declare Sub Moving_net


'-------------------------------------------------------------------------------
'   ===============================
'      ***** Hauptprogramm *****
' ===================================

Do

   Select Case Pina
         Case &B11111111 : Call All_off       '                        00000
         Case &B11111110 : Call All_on       '                        00001
         Case &B11111101 : Call Horizontal_lines       '          00010
         Case &B11111100 : Call Vertical_lines       '              00011
         Case &B11111011 : Call Straight       '                      00100
         Case &B11111010 : Call Diagonal_falling       '           00101
         Case &B11111001 : Call Diagonal_rising       '            00110
         Case &B11111000 : Call Net       '                            00111
         Case &B11110111 : Call Net_invert       '                  01000
         Case &B11110110 : Call Arrow_up       '                    01001
         Case &B11110101 : Call Moving_net       '                 01010


   End Select


Loop


'-------------------------------------------------------------------------------
'  ***  ISR für Timer erzeugen - Overflow-Counter in Warteposition bringen ***

Isr_timer0:
   Timer0 = 177
   Incr Timercounter
' ### Gestartet wird der Timer im jeweiligen Unterprogramm.
' Eingestellt ist der Timer auf 0,01s. ###



'-------------------------------------------------------------------------------
' ====================================
'      ****  Unterprogramme  ****
'   ================================

Sub All_off:       '                00000

   Portd = &B11111111
   Portc = &B11111111
   Portb = &B11111111
   Stop Timer0
   Timer0 = 177

End Sub All_off


Sub All_on:       '                 00001

   Portd = &B00000000
   Portc = &B00000000
   Portb = &B00000000

End Sub All_on


Sub Horizontal_lines:       '       00010

   Portd = &B10101010
   Portb = &B10101010
   Portc = &B10101010

End Sub Horizontal_lines


Sub Vertical_lines:       '         00011

   Portd = &B00000000
   Portc = &B11111111
   Portb = &B00000000

End Sub Vertical_lines


Sub Straight:       '               00100

   Portd = &B11111111
   Portc = &B00000000
   Portb = &B11111111

End Sub Straight


Sub Diagonal_falling :       '      00101

   Portd = &B00100100
   Portc = &B01001001
   Portb = &B10010010

End Sub Diagonal_falling


Sub Diagonal_rising:       '        00110

   Portd = &B10010010
   Portc = &B01001001
   Portb = &B00100100

End Sub Diagonal_rising


Sub Net:  '                         00111

   Portd = &B10101010
   Portc = &B01010101
   Portb = &B10101010

End Sub Net


Sub Net_invert:       '             01000

   Portd = &B01010101
   Portc = &B10101010
   Portb = &B01010101

End Sub Net_invert


Sub Arrow_up:       '               01001

   Portd = &B11011101
   Portc = &B10111011
   Portb = &B11011101

End Sub Arrow_up


Sub Moving_net       '              01010

   Start Timer0
      If Timercounter = 1 Then
         Portd = &B10101010
         Portc = &B01010101
         Portb = &B10101010
      Elseif Timercounter = 120 Then
         Portd = &B01010101
         Portc = &B10101010
         Portb = &B01010101
      Elseif Timercounter = 240 Then
         Timercounter = 0
      End If

End Sub Moving_net

Erläuterungen zu den einzelnen Modulen habe ich nicht mehr beigefügt. Bei Interesse kann man sich das Ergebnis im Code der einzelnen Ports anschauen. Quasi stellen die 3 Ports das Regal dar, welches eigentlich nur nach links gekippt wurde ^^.

Beim letzten Modul mit dem Timer habe ich derzeit noch ein kleines Konflikt-Problem: Die LED leuchten nicht konstant, sondern nur ganz kurz auf, erlöschen sofort wieder und mit dem nächsten Takt erleuchtet die andere LED-Reihe nur ganz kurz - usw.ff. Denke, dass es mit der Ausschalt-Logik zusammenhängt, die ich schreiben musste, wenn kein Eingangsport ein Low-Signal führt. Dann muss die Steuerung nämlich auch alle Ports auf High schalten.

Konfiguriert ist die Steuerung derzeit noch für mein Testboard, das STK-500. Für den Controller selbst muss ich es später komplett invertieren.



LG - Maik

[Searcher]

Hallo,

@ Searcher: Das, was du als Beispiel geschrieben hast, funktioniert leider nicht.

Auf welches Codestück beziehst Du Dich da?

Ich habe Dein letztes Programm von hier gesehen:

Der Code sieht bislang so aus (nach meinem letzten Post geschrieben):

Dort fehlt noch ein Return in der ISR. Aber funktioniert das oder nicht?

Es sollte funktionieren, es sei den die höherwertigen Bits (Bit 5, 6, 7) sind nicht 1. Dadurch, daß in deinem letzten Programm die Pullups eingeschaltet sind, sollten diese Bits auf 1 stehen, so wie Du sie auch im Select-Case abfragst.

Die Leitungen (PA5, PA6, PA7) brauchen/sollten nicht angeschlossen werden, da sie durch die Pullups auf definiertem Pegel liegen. Es schadet auch nichts, sie durch eine extra Variable auf 0 zu setzen wie hier:
Programmwahl = PINA
Programmwahl = Programmwahl AND &B00011111 '(natürlich bei Case berücksichtigen)
Sollen die auf 1 gesetzt werden geht es mit der ODER Verknüfung:
Programmwahl = Programmwahl OR &B11100000


Bitte poste beides, das was geht und das was nicht geht.

Die Eingangsports können nicht an eine Variable übergeben werden.

Das was passieren soll ist, daß der Wert aus Register PINA in die Bytevariable übertragen werden. Das mußßß gehen.

Wenn ich die Variable entsprechend als Byte deklariere und dem Port mit "Programm = PINA" zuweise, kann ich machen was ich will - das Register reagiert nicht auf Tastenbefehle. Schreibe ich allerdings z.B. "If PinA.0 = 0 then ...etc.pp", dann klappt alles.

Wie schon gesagt, bitte poste beide Varianten, die funktionierende und die nicht funktionierende.

Gruß
Searcher

[Sauerbruch]

@ Searcher: Die Eingänge A.7 bis A.5 scheinen korrekt "versorgt" zu sein: Die PullUps sind aktiviert, und in der Case-select-Abfrage beginnt jeder Case mit &b111... . Da sehe ich im Moment jedenfalls keinen Fehler.

@ Maik:
In solchen Fällen finde ich es immer hilfreich, das Programm in kleine Abschnitte zu "zerlegen" und diese einzeln zu überprüfen.
Du könntest z.B. "simulieren", dass die Daten korrekt aus dem PINA-Register übernommen werden, indem Du eine neue Byte-Variable einrichtest, diese alle 3 Sekunden von &b11111111 (=255) auf &b11110101 (=245) runterzählen lässt, und mit dieser Variable die Case-Select Überprüfung durchführst. Wenn sich dann alle 3 Sekunden das Lichtprogramm ändert, müssen wir tatsächlich nochmal irgendwo beim PINA-Register suchen. Praktisch würde ich das so machen:

Dim Zähler as Byte
Zähler = 255
...
do

Select Case Zähler
  Case &b11111111: Call All_off
  Case &b11111110: Call All_on
  .....
  .....
  Case &b11110101: Cal Moving_net

End select

Wait 3    'das aktuelle Unterprogramm wird 3 Sek. ausgeführt

If Zähler = 245 then Zähler = 255 else Zähler = Zähler - 1  'Sorgt dafür, dass Zähler immer zwischen 255 und 245 durchläuft

Loop

(Subroutinen)
..
..

Dass man den Inhalt des PINA-Registers definitiv in eine Variable übernehmen kann (wie Searcher ja auch schon sagte!), steht außer Frage. Allerdings könnte ich mir vorstellen, dass so ein "komplexer" Befehl wie Case Select mit einem Register nicht funktioniert. Von daher wäre dann mein nächster Vorschlag, tatsächlich mit einer Variablen zu arbeiten:

Dim Zähler as Byte
..
Do

Zähler = PINA
Select Case Zähler
  Case &b11111111: Call All_off
  Case &b11111110: Call All_on
  .....
  .....
  Case &b11110101: Cal Moving_net

End select
..
..

Wenn´s dann immer noch nicht geht, müsste man das Register PINA mal genauer unter die Lupe nehmen. Aber probier´ die beiden Sachen doch mal aus!

[stardust19322]

Hallo Freunde.

Wirklich keine Ahnung, woran es lag, aber jetzt plötzlich funktioniert die Variablendeklaration eines Ports. Hier der funktionsfähige Code eines Testprogramms:

$regfile = "m8515.dat"
$crystal = 8000000
$hwstack = 40
$swstack = 16
$framesize = 32


'-------------------------------------------------------------------------------
'  *** Konfiguriere Ein- und Ausgangsports ***

Config Porta = Input
Config Portb = Output

Porta = &HFF       ' Aktiviert die internen Pullup-Widerstände
Portb = &HFF       ' schaltet alle Ausgänge 1, LED = 0
Portc = &HFF
Portd = &HFF


'-------------------------------------------------------------------------------
'  *** Deklarieren der Variablen ***

Dim Zaehler As Byte


'-------------------------------------------------------------------------------
'  *** Deklarieren der Subroutinen ***

Declare Sub Test_1
Declare Sub Test_2



'-------------------------------------------------------------------------------
'   ===============================
'      ***** Hauptprogramm *****
' ===================================

Do

   Zaehler = Pina
   Select Case Zaehler
         Case &B11111110 : Call Test_1
         Case &B11111101 : Call Test_2
   End Select

Loop


Sub Test_1:

   Toggle Portb.2
   Waitms 200

End Sub Test_1


Sub Test_2:

   Toggle Portb.4
   Waitms 200

End Sub Test_2

End

Es funktioniert sogar so gut, dass ich nun auch vermutlich den vermeintlichen "Fehler" bei der Timer-Steuerung gefunden habe. Das Programm läuft ja immer wieder ab, solange die Bedingung an den Eingängen TRUE ist. Bei älteren, ersten Programmversuchen hatte ich immer das Problem, dass das Programm nur solange lief, wie die ISR bestand. Am Ende der ISR wurde die Bedingung aber nicht erneut geprüft, sondern das Programm hielt einfach an. Dadurch musste ich While-Wend-Schleifen einbauen, um damit das Programm die ISR immer wieder durchlief.

Eröffnet mir nun viele neue Möglichkeiten. Wenn ich Probleme dabei habe, melde ich mich sofort wieder.


Danke euch beiden.


LG - Maik