Jetzt aber andersrum, MAX7219 8x8 Matrix 4mal.

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Aufgrund technischer Veränderungen ist der Mailverkehr innerhalb des Forums (Private Nachrichten) nur noch eingeschränkt möglich. Die Einschränkung ist notwendig, um zusätzliche Betriebskosten für das Forum zu vermeiden. Näheres zu den Hintergründen im Thread "Aktuelles zum Forum".Wir bitten um Verständnis.

    Hinweis kann nach Kenntnisnahme deaktiviert werden!

    • Hallo Pluto25,
      ich habe Deine Tabelle die Du am 24.9. angeboten hast verwendet, um neue Zeichen zu regenerieren.
      Das ergab insgesamt 7x3 = 21 Byte.
      Mit dieser Tabelle bin ich dann in mein Programm und es hat funktioniert.
      Aber Du hast zu der "großen" Tabelle am 25.9. eine auf 5x3 = 15 Byte reduzierte Tabelle gebracht und die macht dasselbe.
      Nun meine Frage wie kann ich aus der "großen" Tabelle die kleine Tabelle machen.
      Danke
    • Lothringen schrieb:

      aus der "großen" Tabelle die kleine Tabelle
      Das macht evt Sinn wenn in der großen Version schon ein ganzer Zeichensatz vorhanden ist. z.B ein font der 7x 10 Zeichen hat und je ein Zeichen darstellt. Wobei die Matrix auch mit 7 anstelle 5 Sätzen klarkommt was die Umrechnug nicht zwingend nötig macht. In der Kleinen läßt sich einfacher ein Font reinbringen der Zwei Zeichen nebeneinenader darstellt. Oder eigene Zeichen mit einer Exel-Tabelle erstellen die dann völlig beliebig aussehen können.10x7-Matrix.zip
      Die große Tabelle kommt von Djmsc, der soweit ich das verstanden habe das ganze schon vor einer Weile funktionsfähig hatte?
      Sicher ist es auch möglich die große zur kleinen zu konvertieren aber vielleicht sagst Du mal was es werden soll um nützlichere Tips geben zu können. Weil letzlich entscheidet der Verwendungszweck die Programmgestaltung.
    • Hallo Pluto25,
      also ich habe 2 Stck dieser Matrixen, wo jede 2 Zeichen darstellen kann. Also 4 Zeichen insgesamt.
      Vielleicht läßt sich am Ende damit eine Laufschrift erstellen.
      Aber ich wäre schon zufrieden,wenn ich alle ASC-Zeichen in einer Datentabelle hätte und dann im Programm insgesamt 4 verschiedene dieser Zeichen aufrufen kann und diese verschiedenen Zeichen auf den 4 Matrixen zeigen kann.
      Die Matrixen sind so geschaltet, daß der SEROUT der ersten Matrix zum SERIN der zweiten Matrix geht. Alle anderen Anschlüsse sind bei beiden parallel. Wobei ich nicht weis, ob diese Parallel-Schaltung auch für den Takt gilt.
    • Lothringen schrieb:

      Also 4 Zeichen insgesamt
      Dann müssen 5 Satz a 6 Byte gesendet werden. 5Bit Spaltenadresse + 7 Bit erstes Zeichen + 7 Bit Zweites zeichen + 2*5 Bit zweite und dritte Spaltenadresse + 2* 7 Bit 3. und 4. Zeichen + 5 bit 4.Spaltenadresse.
      z.B.
      0111 1011,1111 1111,1110 1111,0111 1111,1111 1111,1100 1111 für die erste Zeile von ABCD

      Der Takt muß für alle gleich sein damit alle Bits an richtiger Stelle auskommen. Versuchsweise geht es auch mit einer angeschlossenen Doppelmatrix. Sie zeigt dann die letzen beiden Stellen.

      Lothringen schrieb:

      alle ASC-Zeichen in einer Datentabelle
      im Anhag eine (häßliche) Fontdatei die bis R reicht. Sie kann mit dem Fonteditor von Bascom oder
      Peer Gehrmann (Lexikon) aufgehübscht/erweitert werden.
      Dateien
      • 7Seg5x8.zip

        (430 Byte, 13 mal heruntergeladen, zuletzt: )
    • Lothringen schrieb:

      eine Laufschrift erstellen.
      Wie bei einem Lcd ? 40 Zeichen im Speicher von denen 16(20) angezeigt werden. Deren Postion Zeichenweise schiebbar ist. Oder lieber Spaltenweise schiebbar? Mit vieviel Vorgabe (Minimum ein Zeichen mehr als angezeigt werden.
      Ich hab Dein Programm ein wenig auf 4 Anzeigen umgemodelt und Spi eingebaut. Hier habe ich kein passendes
      Modul. Vielleicht testest Du es?
      Dateien
      • loth_10.bas

        (2,85 kB, 10 mal heruntergeladen, zuletzt: )
    • Hallo,
      werde Eure Downloads mal anschauen und testen.
      Für die Laufschrift stehen mir im Moment nur 2 Doppelmatrixen zur Verfügung. Diese habe ich entsprechend geschaltet. Alle Anschlüsse parallel, auch der Takt, nur wird beim 2. Modul SERIN mit SEROUT des 1. Moduls verbunden. Habe auch statt den 15 Bytes 2x 15 Bytes eingestellt, wobei die ersten 15 bei mir die Buchstaben A+B die zweiten die Buchstaben C+D hatten. Doch am Schluß hatte ich auf beiden Modulen nur C+D stehen. Wo A+B geblieben sind, keine Ahnung. Soweit mein Testversuch.

      Gruß
    • Pluto25 schrieb:

      Da wäre jetzt der Code nett.
      Es wird bestimmt der Code sein den ich mal gepostet habe nur eben um zwei Anzeigen erweitert.

      @Lothringen
      Ich bin schon ein ganzes Stück weiter mit dem Programm.
      Es werden aus einem Text vier Buchstaben rausgezogen und auf den vier Anzeigen ausgegeben.
      Nur im Moment noch spiegelverkehrt. Aber daran arbeite ich noch.
      Wenn die Anzeige dann passt, werde ich mich an einen Scrolltext machen.

      PS: Die Anzeigen sind schon etwas tricky :)
      Eine Lösung habe ich nicht, aber mir gefällt Ihr Problem.
    • Hallo,
      Ich habe eine Idee wie 2 Matrixen so angesteuert werden, daß 4 Zeichen möglich sind.
      Dazu habe ich für jede Matrix eine eigene Datenleitung eingesetzt.
      Es funktioniert.
      Hier das Listing (wegen Überlänge ohne Zeichensatz)
      Vielleicht lassen sich damit noch mehr Matrixen ansteuern.
      Gruß

      Hat jemand eine Laufschrift für die Matrixen??

      BASCOM-Quellcode: Zwei Doppelmatrixen mit je 2mal 5x7 = 4 Zeichen

      1. 'Matrix 5x7 Matrix 4 Zeichen voller Zeichensatz
      2. $regfile = "m8adef.dat" 'Prozessor
      3. $crystal = 3684000 'Taktfrequenz
      4. $baud = 19200
      5. $hwstack = 80
      6. $swstack = 80
      7. $framesize = 100
      8. Takt Alias Portb.5 'B.5 an SRCLK = Takt
      9. Config Takt = Output
      10. Daten Alias Portb.3 'B.3 an Serin2 = Dateneingabe
      11. Config Daten = Output
      12. Datenb Alias Portb.4 'B.4 an Serin1
      13. Config Datenb = Output
      14. Uebernahme Alias Portb.2 'B.2 an RCLK = Übernahme
      15. Config Uebernahme = Output
      16. 'OE = 0 = Output enable = Matrix ein/aus ; /SRCLK an VCC
      17. Dim Spa As String * 5 'Spalten Anfang + Ende
      18. Dim B(4) As String * 7
      19. Dim C(4) As Byte
      20. Dim Speicher(30) As Byte
      21. Dim I As Byte 'Spaltenzähler
      22. Dim N As Byte 'Speicherzähler
      23. Dim K As Byte
      24. Dim L As Byte
      25. Dim M As Byte
      26. Dim R(4) As String * 8
      27. Dim Text As String * 5
      28. Dim Buch(4) As Word
      29. Dim Matr(2) As Word
      30. Dim Zaehler As Byte
      31. Config Spi = Soft , Din = Pinb.4 , Dout = Daten , Ss = Uebernahme , Clock = Takt , Mode = 0 'SPI-Soft
      32. Spiinit 'SPI initialisieren
      33. Waitms 50
      34. '-------------------------------------------------
      35. Text = "Test" 'Texteingabe
      36. '-------------------------------------------------
      37. 'Zeichen auf Buchstabenliste setzen
      38. For I = 1 To 4
      39. R(i) = Mid(text , I , 1) 'Buchstabe lesen
      40. Buch(i) = Asc(r(i)) 'ASC-Code
      41. Buch(i) = Buch(i) - 32 'Tabelle beginnt bei 32
      42. Buch(i) = Buch(i) * 5 'Tabellenspalte
      43. Next I
      44. 'Zeichen steuern
      45. N = 1
      46. L = 1
      47. M = 2
      48. Gosub Zeichen
      49. N = 16
      50. L = 3
      51. M = 4
      52. Gosub Zeichen
      53. 'Zeichen ausgeben
      54. Do
      55. Gosub Anzeigea
      56. Gosub Anzeigeb
      57. Loop
      58. End
      59. 'Zeichen vorbereiten und speichern
      60. Zeichen:
      61. For I = 0 To 4
      62. For K = L To M
      63. Matr(k) = Buch(k) + I
      64. C(k) = Lookup(matr(k) , Buchstabenliste)
      65. B(k) = Bin(c(k))
      66. Next K
      67. Spa = Lookupstr(i , Grund) 'Spalten Anfang+Ende
      68. R(1) = Spa + Left(b(l) , 3)
      69. R(2) = Mid(b(l) , 4 , 4) + Left(b(m) , 4)
      70. R(3) = Mid(b(m) , 5 , 3) + Spa
      71. Speicher(n) = Binval(r(1)) 'in Binär-Code wandeln
      72. Speicher(n + 1) = Binval(r(2))
      73. Speicher(n + 2) = Binval(r(3))
      74. N = N + 3
      75. Next I
      76. Return
      77. Anzeigea:
      78. For Zaehler = 1 To 15 Step 3
      79. Shiftout Daten , Takt , Speicher(zaehler) , 1
      80. Shiftout Daten , Takt , Speicher(zaehler + 1) , 1
      81. Shiftout Daten , Takt , Speicher(zaehler + 2) , 1
      82. Uebernahme = 0
      83. Uebernahme = 1
      84. Next Zaehler
      85. Return
      86. Anzeigeb:
      87. For Zaehler = 16 To 30 Step 3
      88. Shiftout Datenb , Takt , Speicher(zaehler) , 1
      89. Shiftout Datenb , Takt , Speicher(zaehler + 1) , 1
      90. Shiftout Datenb , Takt , Speicher(zaehler + 2) , 1
      91. Uebernahme = 0
      92. Uebernahme = 1
      93. Next Zaehler
      94. Return
      95. End
      96. Grund:
      97. Data "01111" , "10111" , "11011" , "11101" , "11110"
      98. 'Hier Buchstabenliste (=Zeichensatz) anfügen
      Alles anzeigen
    • Lothringen schrieb:

      eine Laufschrift
      Mit wie viel Zeichen? Bis ca 10 würden in den Speicher passen. Soll es ganze Sätze werden müsten sie während der Laufzeit aufbereitet werden.
      Die SW Spi kommt nicht zum Einsatz. Sie wäre etwas schneller (und einfacher)
      Config Spi = Soft , Dout = Daten , Ss = None , Mode = 0 'SPI-Soft
      .
      .
      Spiout Speicher(zaehler) , 3

      Ein bisschen Zeichensatz wäre schön gewesen zum Simulieren.
      Weshalb zwei Satz ? Schoben sie nicht richtig durch? ;(
      sind jetzt nicht die letzten Spalten etwas heller als der Rest?
      Mit der Software Lösung wirds bei ca 4 beginnen zu flackern.
      Mit HW Spi vorsichtig geschätzt bei > 20
      Ps das Waitms hinter dem Spiinit ist unnötig (Es braucht nicht "Warmzulaufen" :D )
    • BASCOM-Quellcode

      1. Spa = Lookupstr(i , Grund) 'Spalten Anfang+Ende
      2. R(1) = Spa + Left(b(l) , 3)
      3. R(2) = Mid(b(l) , 4 , 4) + Left(b(m) , 4)
      4. R(3) = Mid(b(m) , 5 , 3) + Spa
      5. Speicher(n) = Binval(r(1)) 'in Binär-Code wandeln
      6. Speicher(n + 1) = Binval(r(2))
      7. Speicher(n + 2) = Binval(r(3))
      Hier wird auch viel zu viel umgewandelt. Das kann man einfacher machen. Schau dir dazu noch mal meinen Programmvorschlag an.
      Eine Lösung habe ich nicht, aber mir gefällt Ihr Problem.