Mikrobasic, Interrupts en multiplexen

Aantal displays is onbelangrijk: je moet het als één plaatje zien...
Index op de gewenste waarde zetten, en dan routine 48x aanroepen...

pic basic code:


Dim Index  As Byte
    Buffer As Byte[48]

Sub Function Read_Buffer() As Byte
  Result = Buffer[Index]
  Inc(Index)
  If Index > 47 Then Index = 0 End If
End Sub

[Bericht gewijzigd door Arco op 6 januari 2020 20:16:53 (12%)]

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

Ik ben ermee aan het worstelen, maar het lukt niet echt.
Als het nu een één schuifregister was met 6 * 8 = 48 bytes. ;(

[Bericht gewijzigd door Bavelt op 6 januari 2020 20:59:14 (36%)]

Het is één schuifregister, de chips zitten aan mekaar geknoopt...

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

Ja, dat dacht ik ook.
Toch kun je ze volgens mij niet als 1 benaderen.
of ik zie het (waarschijnlijk) verkeerd.

Voor iedere display (met MAX7219) moet ik een SPI_Write doen,
en dit steeds 6 keer voor alle displays samen.

Maar dan krijg ik weer het knipper-effect.
Dat Frame-buffer heb ik nog niet helder.

Dim Index As Byte
Buffer As Byte[48]

Sub Function Read_Buffer() As Byte
Result = Buffer[Index]
Inc(Index)
If Index > 47 Then Index = 0 End If
End Sub

Dit zag ik nu pas. Ga ik eens mee spelen.

Je maakt nu voor iedere write de chipselect laag, en daarna weer hoog? Dat moet niet.
Je moet de chipselect laag maken, naar alle displays schrijven, en dan weer hoog maken...

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

Nee, niet na iedere write.
Ik gebruik deze routine:

pic basic code:

'===============================================================================
Sub Procedure Max_Write(Dim pRow, pDig0, pDIg1, pDig2, pDig3, pDig4, pDig5 as Byte)
'===============================================================================
 Latch = 0
 SPI1_Write(pRow)
 SPI1_Write(pDig0)
 SPI1_Write(pRow)
 SPI1_Write(pDig1)
 SPI1_Write(pRow)
 SPI1_Write(pDig2)
 SPI1_Write(pRow)
 SPI1_Write(pDig3)
 SPI1_Write(pRow)
 SPI1_Write((pDig4))
 SPI1_Write(pRow)
 SPI1_Write(pDig5)
 Latch = 1
 delay_ms(2)
End sub 

Maar dan nog zie ik de relatie niet tussen de Read_buffer routine en de te tonen tekst.
Die zit in een string, bv str = "123456789" (tot maximaal 120 tekens).

De size van 48 bytes is vanwege 6 displays * 8 rijen, neem ik aan. Terwijl de byte de inhoud aangeeft.

Maar hoe vertaal ik de te tonen inhoud dan naar de Max-write routine?

pDig0 is Index, pDig1 = Index+8, pDig2 = Index+16,enz...
(wel rekening houden met de 'wrap-around' naar nul aan het einde)

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

Ik zit echt op een andere golflengte vrees ik... :?

Ik had deze routine:

pic basic code:

For i1 = 0 to (Length(str) - 1)
   For Row = 1 to 8
    For x1 = 0 to 5
    if i1 >= x1 then Inhoud[x1] = Font1[((Str[i1 - x1] - 0x20) <<3) + (Row - 1)] else Inhoud[x1] = 0x00 end if
    Next x1
    max_Write(Row, Inhoud[0], Inhoud[1],  Inhoud[2],
                   Inhoud[3], Inhoud[4],  Inhoud[5]
                   )
    Delay_ms(5)
  Next Row
  Delay_ms(200)
  Next i1

Hier wordt de string sequentieel doorlopen en naar de displays gezonden.
Maar hoe pas ik die Read_Buffer daar nu in?

Zo loopt het wel redelijk vloeiend.
Het enige nadeel is dat wanneer een display gevuld is, ze allemaal even uit gaan voordat een nieuwe karakter rechts inschuift.

pic basic code:

For i1 = 0 to (Length(str) - 1)
  for j1 = 7 to 0 step -1
   For Row = 1 to 8
    For x1 = 0 to 5
       if i1 >= x1 then Inhoud[x1] = Font1[((Str[i1 - x1] - 0x20) <<3) + (Row - 1)] else Inhoud[x1] = 0x00 end if
    Next x1
    max_Write(Row, Inhoud[0]<<j1, Inhoud[1]<<j1,  Inhoud[2]<<j1,
                   Inhoud[3]<<j1, Inhoud[4]<<j1,  Inhoud[5]<<j1
                   )
    Delay_ms(5)
  Next Row
  Delay_ms(10)
  next j1
  Next i1

Het blijft puzzelen. De schuifoperatie for j1 = 7 to 0 step -1 is de stoorzender, die veroorzaakt dat alle displays op blank gaan bij wisseling van karakter.

pic basic code:

if i1 >= x1 then Inhoud[x1] = Font1[((Str[i1 - x1] - 0x20) <<3) + (Row - 1)] else Inhoud[x1] = 0x00 end if

Ik volg dit niet echt maar ik vraag mij af waarom je Inhoud[x1]= 0x00 maakt, je moet toch enkel de data volgen en geen bijvoegen.

edit: is Mikrobasic case sensitive? anders staat er een foutje in, pDIg1 moet pDig1 zijn.

pic basic code:

Sub Procedure Max_Write(Dim pRow, pDig0, pDIg1, pDig2, pDig3, pDig4, pDig5 as Byte)
LDmicro user.

De 0x00 zit erin om te voorkomen dat je ongewenste tekens op de 1e 5 displays krijgt vóórdat de eerste "echte" letter uit de string komt.
Zie het maar als een voorloop 0.
In MikroBasic kun je case sensitive uitzetten; heb ik gedaan.

Gepost maandag 6 januari 2020 22:54:12 |Quoten
pDig0 is Index, pDig1 = Index+8, pDig2 = Index+16,enz...
(wel rekening houden met de 'wrap-around' naar nul aan het einde)

Ik zie dat je dit in een eerdere post uit 2017 ook hebt gemeld. Ik zal nog eens een poging ondernemen dit te doorgronden... :)

't Is een ringbuffer. Als je index verplaatst, scrollt de tekst...

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

Ik heb wat geprobeerd. Er volgt een mooie bewegende creatie op de display, een waar kunstwerk. Alleen niet wat je zou mogen verwachten (123456).
Ik heb een string van 6 bytes voor het gemak gemaakt. Index op 1.

pic basic code:



Str = "123456"

  'Loop ----------------------------------------------------------------------

  While True

  Buffer = Str
  Index = 1

  for i1 = 0 to 5
       CharX = Read_Buffer()
       For Row = 1 to 8
          Max_Write(Row, Font1[((CharX - 0x20) <<3) + (Row - 1)],
                         Font1[((CharX - 0x20) <<3) + (Row - 1)],
                         Font1[((CharX - 0x20) <<3) + (Row - 1)],
                         Font1[((CharX - 0x20) <<3) + (Row - 1)],
                         Font1[((CharX - 0x20) <<3) + (Row - 1)],
                         Font1[((CharX - 0x20) <<3) + (Row - 1)])
        Delay_ms(50)
        inc(Index)
       Next Row
       delay_ms(10)
  next i1
 

Op 7 januari 2020 10:49:58 schreef Arco:
't Is een ringbuffer. Als je index verplaatst, scrollt de tekst...

[bijlage]

Wat een lastig karwei.. :'(

Wat ik ervan begrijp is dat je een schuifregister hebt van 48 bytes (= 6 displays van 8 bytes).
In dat register stop je de te scrollen tekst.

Die stuur je continu naar de displays (in porties van 6)
Maar een karakter op het display vergt 8 bytes. Dat doe je met de rows.

Dan gooi ik dit alles in de pot, maar het strandt steeds... :?

't Is een ringbuffer. Als je index verplaatst, scrollt de tekst...

Zijn dit nu bits of bytes?

Als het bytes zijn, dan schijf je met de Read_Buffer toch een hele byte op?
Maar je wilt toch maar 1 rijtje opschuiven ipv 8 tegelijk?

Op 7 januari 2020 16:04:37 schreef Bavelt:
[bijlage]

[...]

Zijn dit nu bits of bytes?

Als het bytes zijn, dan schuif je met de Read_Buffer toch een hele byte op?
Maar je wilt toch maar 1 rijtje opschuiven ipv 8 tegelijk?

-

[Bericht gewijzigd door Bavelt op 7 januari 2020 16:06:18 (100%)]

Zie dit voorbeeld.
Om het makkelijk te maken, even 1 rij.

pic basic code:

Leegmaken buffer
 for i1 = 0 to 47
    Buffer[i1] = %00000000
 Next i1

  Buffer[0] = %00000001
  Buffer[1] = %00000011
  Buffer[2] = %00000111
  Buffer[3] = %00001111
  Buffer[4] = %00011111
  Buffer[5] = %00111111
  
  Index = 0
  Row = 1
       Inhoud[0] = Read_Buffer()
       Inhoud[1] = Read_Buffer()
       Inhoud[2] = Read_Buffer()
       Inhoud[3] = Read_Buffer()
       Inhoud[4] = Read_Buffer()
       Inhoud[5] = Read_Buffer()
       max_Write(Row, Inhoud[0], Inhoud[1], Inhoud[2], Inhoud[3], Inhoud[4], Inhoud[5])
       Delay_ms(100)

  Wend

eerste display 1 ledje, 2e twee, etc.
Hoe schuif ik nu alles 1 rijtje door en dat het een lus wordt?

Zo krijg ik het wel aan het schuiven (naar rechts, omdat na elke Read_Buffer de index automatisch met 1 wordt verhoogd), maar inderdaad met een hele display tegelijk.

terwijl het de bedoeling is om 1 rijtje op te schuiven...

pic basic code:

'Leegmaken buffer
 for i1 = 0 to 47
    Buffer[i1] = %00000000
 Next i1

  Index = 0

  Buffer[0] = %00000001
  Buffer[1] = %00000011
  Buffer[2] = %00000111
  Buffer[3] = %00001111
  Buffer[4] = %00011111
  Buffer[5] = %00111111
  
  Row = 1
  For I1 = 0 to 5
       Inhoud[0] = Read_Buffer()
       Inhoud[1] = Read_Buffer()
       Inhoud[2] = Read_Buffer()
       Inhoud[3] = Read_Buffer()
       Inhoud[4] = Read_Buffer()
       Inhoud[5] = Read_Buffer()
       max_Write(Row, Inhoud[0], Inhoud[1], Inhoud[2], Inhoud[3], Inhoud[4], Inhoud[5])
       Delay_ms(2000)
       Index = Index - 5
  Next I1

Ik ben inmiddels al een stuk verder met het omzetten van het programma om via een framebuffer de displays aan te sturen.
Nu is het bij mijn displays zo (zitten aan elkaar vast, 6 stuks), dat ze niet met kolommen werken, maar met rijen.

Het resultaat is dat het scrollen wel werkt, maar dat gaat nu dus van boven naar onder (en omgekeerd).

Het plaatje van Arco (zie boven) gaat ervan uit dat het met kolommen werkt.
Daar wordt inhoud steeds een kolom opgeschoven met een index. Als ik horizontaal wil scrollen moet ik dus de inhoud wijzigen ipv de kolom. Dat blijkt een stuk lastiger.

Is er wellicht een manier om rijen/kolommen om te draaien?

@Arco, zou jij eens met me willen meekijken?
Ik ben nl een aantal dagen intensief bezig geweest met het scrollen, maar krijg het niet voor elkaar.
Ook niet na een aantal paracetamolletjes... ;(

Ik heb inmiddels 2 andere displays met MAX7219, die 'rechtop' staan zodat ik met kolommen kan werken.

Ik heb een buffer gemaakt, waarvan de inhoud naar de displays wordt gestuurd. Die schuif ik eentje op, dat scrollen werkt.

Mbv een hulpbit stop ik het uitgeschoven bit er weer in, zodat ik een ringbuffer krijg.

Maar mijn probleem is om een nieuw karakter uit de input string in de buffer te lezen.
Dan gaat er steeds van alles fout, alle pogingen ten spijt.
Er zit iets in deze constructie dat maakt dat het moeilijk wordt.

Zou je er eens een blik op willen werpen?

pic basic code:


program LichtKrant_6Display
'Display Matrix Led 8 * 8, type 1088AS

Dim ClockPin   as sbit at LATB.4        'pin 10
    Latch      as sbit at LATB.3        'pin 9
    Datapin    as sbit at LATB.2        'pin 8

    Light      as Byte                  'Intensity
    Col        as Byte
    Display    as Byte
    i1         as Byte
    j1         as Byte
    o1         as Byte                  'testbyte
    x1         as Byte                  'testbyte
    y1         as Integer               'testbyte
    z1         as Integer               'testbyte

    Inhoud     as Byte[6]
    Str        as String[26]
    LenStr     as Byte
    CharX      as Char
    
    Index      as Byte
    Ind1       as Byte
    Buffer     as Byte[16]

const Font1 As Byte[760] = (                                   'Character table
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              'space'
  0x18, 0x00, 0x18, 0x18, 0x3c, 0x3c, 0x18, 0x00,              '!
  0x00, 0x00, 0x00, 0x00, 0x28, 0x6c, 0x6c, 0x00,              '"
  0x6c, 0x6c, 0xfe, 0x6c, 0xfe, 0x6c, 0x6c, 0x00,              '#
  0x10, 0x3c, 0x40, 0x38, 0x04, 0x78, 0x10, 0x00,              '$
  0x60, 0x66, 0x0c, 0x18, 0x30, 0x66, 0x06, 0x00,              '%
  0xfc, 0x66, 0xa6, 0x14, 0x3c, 0x66, 0x3c, 0x00,              '&
  0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x30, 0x00,              ''
  0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00,              '(
  0x06, 0x0c, 0x18, 0x18, 0x18, 0x0c, 0x06, 0x00,              ')
  0x00, 0x6c, 0x38, 0xfe, 0x38, 0x6c, 0x00, 0x00,              '*
  0x00, 0x10, 0x10, 0x7c, 0x10, 0x10, 0x00, 0x00,              '+
  0x06, 0x0c, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00,              ',
  0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00,              '-
  0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              '.
  0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x00, 0x00,              '/
  0x3c, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x00,              '0
  0x7e, 0x18, 0x18, 0x18, 0x1c, 0x18, 0x18, 0x00,              '1
  0x7e, 0x06, 0x0c, 0x30, 0x60, 0x66, 0x3c, 0x00,              '2
  0x3c, 0x66, 0x60, 0x38, 0x60, 0x66, 0x3c, 0x00,              '3
  0x30, 0x30, 0x7e, 0x32, 0x34, 0x38, 0x30, 0x00,              '4
  0x3c, 0x66, 0x60, 0x60, 0x3e, 0x06, 0x7e, 0x00,              '5
  0x3c, 0x66, 0x66, 0x3e, 0x06, 0x66, 0x3c, 0x00,              '6
  0x18, 0x18, 0x18, 0x30, 0x30, 0x66, 0x7e, 0x00,              '7
  0x3c, 0x66, 0x66, 0x3c, 0x66, 0x66, 0x3c, 0x00,              '8
  0x3c, 0x66, 0x60, 0x7c, 0x66, 0x66, 0x3c, 0x00,              '9
  0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00,              ':
  0x0c, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00,              ';
  0x60, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x60, 0x00,              '<
  0x00, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x00, 0x00,              '=
  0x06, 0x0c, 0x18, 0x30, 0x18, 0x0c, 0x06, 0x00,              '>
  0x18, 0x00, 0x18, 0x38, 0x60, 0x66, 0x3c, 0x00,              '?
  0x00, 0x3c, 0x42, 0x1a, 0x3a, 0x22, 0x1c, 0x00,              '@
  0x00, 0x3f, 0x7f, 0x48, 0x48, 0x7f, 0x3f, 0x00,              'A
  0x00, 0x36, 0x7f, 0x49, 0x49, 0x7f, 0x7f, 0x00,              'B
  0x00, 0x22, 0x63, 0x41, 0x41, 0x7f, 0x3e, 0x00,              'C
  0x00, 0x3e, 0x7f, 0x41, 0x41, 0x7f, 0x7f, 0x00,              'D
  0x00, 0x41, 0x49, 0x49, 0x49, 0x7f, 0x7f, 0x00,              'E
  0x00, 0x40, 0x48, 0x48, 0x48, 0x7f, 0x7f, 0x00,              'F
  0x00, 0x26, 0x67, 0x45, 0x41, 0x7f, 0x3e, 0x00,              'G
  0x00, 0x7f, 0x7f, 0x08, 0x08, 0x7f, 0x7f, 0x00,              'H
  0x00, 0x00, 0x41, 0x7f, 0x7f, 0x41, 0x00, 0x00,              'I
  0x00, 0x40, 0x7e, 0x7f, 0x41, 0x07, 0x06, 0x00,              'J
  0x00, 0x41, 0x63, 0x36, 0x1c, 0x7f, 0x7f, 0x00,              'K
  0x00, 0x01, 0x01, 0x01, 0x01, 0x7f, 0x7f, 0x00,              'L
  0x7f, 0x7f, 0x30, 0x18, 0x30, 0x7f, 0x7f, 0x00,              'M
  0x7f, 0x7f, 0x0c, 0x18, 0x30, 0x7f, 0x7f, 0x00,              'N
  0x00, 0x3e, 0x7f, 0x41, 0x41, 0x7f, 0x3e, 0x00,              'O
  0x00, 0x38, 0x7c, 0x44, 0x44, 0x7f, 0x7f, 0x00,              'P
  0x00, 0x3d, 0x7f, 0x46, 0x42, 0x7e, 0x3c, 0x00,              'Q
  0x00, 0x31, 0x7b, 0x4e, 0x4c, 0x7f, 0x7f, 0x00,              'R
  0x00, 0x26, 0x6f, 0x49, 0x49, 0x7b, 0x32, 0x00,              'S
  0x00, 0x60, 0x40, 0x7f, 0x7f, 0x40, 0x60, 0x00,              'T
  0x00, 0x7f, 0x7f, 0x01, 0x01, 0x7f, 0x7e, 0x00,              'U
  0x00, 0x7c, 0x7e, 0x03, 0x03, 0x7e, 0x7c, 0x00,              'V
  0x7f, 0x7f, 0x06, 0x0c, 0x06, 0x7f, 0x7f, 0x00,              'W
  0x63, 0x77, 0x1c, 0x08, 0x1c, 0x77, 0x63, 0x00,              'X
  0x00, 0x70, 0x78, 0x0f, 0x0f, 0x78, 0x70, 0x00,              'Y
  0x00, 0x61, 0x71, 0x59, 0x4d, 0x47, 0x43, 0x00,              'Z
  0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x00,              '[
  0x00, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x00, 0x00,              '\
  0x1e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1e, 0x00,              ']
  0x00, 0x00, 0x00, 0x82, 0x44, 0x28, 0x10, 0x00,              '^
  0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              '_
  0x00, 0x00, 0x00, 0x0c, 0x18, 0x18, 0x18, 0x00,              ''
  0x7c, 0x66, 0x7c, 0x60, 0x3c, 0x00, 0x00, 0x00,              'a
  0x3e, 0x66, 0x66, 0x3e, 0x06, 0x06, 0x06, 0x00,              'b
  0x3c, 0x66, 0x06, 0x66, 0x3c, 0x00, 0x00, 0x00,              'c
  0x7c, 0x66, 0x66, 0x7c, 0x60, 0x60, 0x60, 0x00,              'd
  0x3c, 0x06, 0x7e, 0x66, 0x3c, 0x00, 0x00, 0x00,              'e
  0x0c, 0x0c, 0x3e, 0x0c, 0x0c, 0x6c, 0x38, 0x00,              'f
  0x3c, 0x60, 0x7c, 0x66, 0x66, 0x7c, 0x00, 0x00,              'g
  0x66, 0x66, 0x66, 0x3e, 0x06, 0x06, 0x06, 0x00,              'h
  0x3c, 0x18, 0x18, 0x18, 0x00, 0x18, 0x00, 0x00,              'i
  0x1c, 0x36, 0x36, 0x30, 0x30, 0x00, 0x30, 0x00,              'j
  0x66, 0x36, 0x1e, 0x36, 0x66, 0x06, 0x06, 0x00,              'k
  0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00,              'l
  0xd6, 0xd6, 0xfe, 0xee, 0xc6, 0x00, 0x00, 0x00,              'm
  0x66, 0x66, 0x66, 0x7e, 0x3e, 0x00, 0x00, 0x00,              'n
  0x3c, 0x66, 0x66, 0x66, 0x3c, 0x00, 0x00, 0x00,              'o
  0x06, 0x06, 0x3e, 0x66, 0x66, 0x3e, 0x00, 0x00,              'p
  0xf0, 0xb0, 0x3c, 0x36, 0x36, 0x3c, 0x00, 0x00,              'q
  0x06, 0x06, 0x66, 0x66, 0x3e, 0x00, 0x00, 0x00,              'r
  0x3e, 0x40, 0x3c, 0x02, 0x7c, 0x00, 0x00, 0x00,              's
  0x18, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00,              't
  0x7c, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00,              'u
  0x18, 0x3c, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00,              'v
  0x7c, 0xd6, 0xd6, 0xd6, 0xc6, 0x00, 0x00, 0x00,              'w
  0x66, 0x3c, 0x18, 0x3c, 0x66, 0x00, 0x00, 0x00,              'x
  0x3c, 0x60, 0x7c, 0x66, 0x66, 0x00, 0x00, 0x00,              'y
  0x3c, 0x0c, 0x18, 0x30, 0x3c, 0x00, 0x00, 0x00,              'z
  0x70, 0x18, 0x18, 0x0c, 0x18, 0x18, 0x70, 0x00,              '{
  0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00,              '|
  0x0e, 0x18, 0x18, 0x30, 0x18, 0x18, 0x0e, 0x00,              '}
  0x00, 0x00, 0x00, 0x36, 0x5c, 0x00, 0x00, 0x00               '~
  )

'===============================================================================
Sub Procedure Max_Write(Dim pCol, pDig0, pDIg1 as Byte)
'===============================================================================
 Latch = 0
 SPI1_Write(pCol)
 SPI1_Write(pDig0)
 SPI1_Write(pCol)
 SPI1_Write(pDig1)
 Latch = 1
 delay_ms(2)
End sub

'===============================================================================
Sub Procedure Max7219_Init()
'===============================================================================
Max_Write(0x09, 0x00, 0x00)
Max_Write(0x0B, 0x07, 0x07)
Max_Write(0x0C, 0x01, 0x01)
Max_Write(0x0A, 0x01, 0x01)
End sub

'===============================================================================
Sub Procedure Display_Testen()      'Testen van het display; alle LEDS aan
'===============================================================================
Max_Write(0x0F, 0x01, 0x01)
DELAY_MS(5)
Max_Write(0x0F, 0x00, 0x00)
DELAY_MS(5)
End sub

'===============================================================================
Sub Procedure Uitzetten_Leds()      'Leds uitzetten per Row
'===============================================================================
FOR Col = 1 TO 8
   Max_Write(Col, 0x00, 0x00)
   delay_ms(5)
NEXT Col
End sub


'===============================================================================
Sub Function Read_Str() As Byte
'===============================================================================
Result = Str[index]
Inc(Index)
If Index > 25 Then Index = 0 End if
End Sub

'===============================================================================
Sub Procedure Display_Schrijven()
'===============================================================================
   'Inhoud Buffer naar Displays sturen
   For Col = 1 to 8
       max_Write(Col, Buffer[0 + (Col - 1)], Buffer[8 + (Col - 1)])
       delay_ms(2)
   Next Col
       delay_ms(2)
End Sub

'===============================================================================
Main:

'===============================================================================
  OSCCON     = %01110000                                      '8Mhz internal
  ANSELA     = %00000000                                      'Port %   digital
  ANSELB     = %00000000                                      'Port %   digital
  TRISA      = %11111111
  TRISB      = %00000000
  PORTA      = %11111111
  SPI1_Init()
  Max7219_Init()
  Display_Testen()
  delay_ms(500)
  Uitzetten_Leds()

  'Loop ----------------------------------------------------------------------
   'Leegmaken Buffer
    For i1 = 0 to 15
       Buffer[i1] = 0x00
    Next i1

  Str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  Index = 0
                                       'Initieel de Buffer vullen met "A" en "B"
  CharX = Read_Str()
  for y1 = 0 to 7
      Buffer[y1] = Font1[((CharX - 0x20) <<3) + y1]
  next y1
  CharX = Read_Str()
  for y1 = 8 to 15
      Buffer[y1] = Font1[((CharX - 0x20) <<3) + y1 - 8]
  next y1
  

  While True

                                        'Scrollen, alle bytes 1 opschuiven
    for z1 = 0 to 15
     o1 = Buffer[15]                    'tijdelijk, deze byte wordt uitgeschoven
     For j1 = 15 to 0 step -1
        Buffer[j1] = Buffer[j1 - 1]
     next j1
     Buffer[0] = o1                     'uitgeschoven byte weer in ring brengen

     Display_Schrijven()
     delay_ms(250)
    next z1
    
 wend
  End.