Mikrobasic, Interrupts en multiplexen

Bavelt

Golden Member

Uiteindelijk is het gelukt!

Het is al met al nog best wel een simpel programma geworden.

Voor de geïnteresseerden hieronder het programma.
Processor: PIC16f1847
Taal: MikroBasic
Frequentie: 8 Mhz intern

Het programma maakt gebruik van 2 LED Matrixen, 8*8 Leds, aangestuurd door MAX7219 chips.

pic basic code:


Program LichtKrant_2Display
'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

    x1         as Byte
    y1         as Integer

    Str        as String[95]
    LenStr     as Byte
    CharX      as Char

    Index      as Byte
    Buffer     as Byte[16]

Const Font As Byte[760] =  (                                   'Character table
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              'space'
  0x00, 0x00, 0x30, 0x7d, 0x7d, 0x30, 0x00, 0x00,              '!
  0x00, 0x36, 0x36, 0x14, 0x00, 0x00, 0x00, 0x00,              '"
  0x6c, 0x6c, 0xfe, 0x6c, 0xfe, 0x6c, 0x6c, 0x00,              '#
  0x00, 0x24, 0x2a, 0x6b, 0x2a, 0x12, 0x00, 0x00,              '$
  0x00, 0x23, 0x33, 0x18, 0x0c, 0x66, 0x62, 0x00,              '%
  0x05, 0x23, 0x77, 0x59, 0x51, 0x7f, 0x26, 0x00,              '&
  0x00, 0x00, 0x00, 0x70, 0x78, 0x08, 0x00, 0x00,              ''
  0x00, 0x41, 0x63, 0x3e, 0x1c, 0x00, 0x00, 0x00,              '(
  0x00, 0x00, 0x00, 0x1c, 0x3e, 0x63, 0x41, 0x00,              ')
  0x08, 0x2a, 0x3e, 0x1c, 0x3e, 0x2a, 0x08, 0x00,              '*
  0x00, 0x10, 0x10, 0x7c, 0x10, 0x10, 0x00, 0x00,              '+
  0x00, 0x00, 0x00, 0x00, 0x0e, 0x0f, 0x01, 0x00,              ',
  0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,              '-
  0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00,              '.
  0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x00,              '/
  0x00, 0x7c, 0xfe, 0x82, 0x82, 0x82, 0xfe, 0x7c,              '0
  0x00, 0x00, 0x02, 0x02, 0xfe, 0xfe, 0x42, 0x02,              '1
  0x00, 0x00, 0x66, 0xf6, 0x92, 0x9a, 0xce, 0x46,              '2
  0x00, 0x00, 0x6c, 0xfe, 0x92, 0x92, 0xc6, 0x44,              '3
  0x00, 0x0a, 0xfe, 0xfe, 0xca, 0x68, 0x38, 0x18,              '4
  0x00, 0x00, 0x9c, 0xbe, 0xa2, 0xa2, 0xe6, 0xe4,              '5
  0x00, 0x0c, 0x9e, 0x92, 0xd2, 0x7e, 0x3c, 0x00,              '6
  0x00, 0x00, 0xe0, 0xf0, 0x9e, 0x8e, 0xc0, 0xc0,              '7
  0x00, 0x00, 0x6c, 0xfe, 0x92, 0x92, 0xfe, 0x6c,              '8
  0x00, 0x00, 0x78, 0xfc, 0x96, 0x92, 0xf2, 0x60,              '9
  0x00, 0x00, 0x00, 0x36, 0x36, 0x00, 0x00, 0x00,              ':
  0x00, 0x00, 0x00, 0x36, 0x37, 0x01, 0x00, 0x00,              ';
  0x00, 0x41, 0x63, 0x36, 0x1c, 0x08, 0x00, 0x00,              '<
  0x00, 0x00, 0x14, 0x14, 0x14, 0x14, 0x00, 0x00,              '=
  0x00, 0x00, 0x08, 0x1c, 0x36, 0x63, 0x41, 0x00,              '>
  0x00, 0x30, 0x78, 0x4d, 0x4d, 0x60, 0x20, 0x00,              '?
  0x00, 0x04, 0x32, 0x5a, 0x5a, 0x42, 0x3c, 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
  0x00, 0x41, 0x41, 0x7f, 0x7f, 0x00, 0x00, 0x00,              '[
  0x00, 0x04, 0x0c, 0x18, 0x30, 0x60, 0x40, 0x00,              '\
  0x00, 0x00, 0x00, 0x7f, 0x7f, 0x41, 0x41, 0x00,              ']
  0x08, 0x10, 0x20, 0x40, 0x20, 0x10, 0x08, 0x00,              '^
  0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x00,              '_
  0x00, 0x00, 0x00, 0x0c, 0x18, 0x18, 0x18, 0x00,              ''
  0x00, 0x0f, 0x1f, 0x15, 0x15, 0x17, 0x02, 0x00,              'a
  0x00, 0x06, 0x0f, 0x09, 0x09, 0x7f, 0x7f, 0x00,              'b
  0x00, 0x0a, 0x1b, 0x11, 0x11, 0x1f, 0x0e, 0x00,              'c
  0x00, 0x7f, 0x7f, 0x09, 0x09, 0x0f, 0x06, 0x00,              'd
  0x00, 0x0c, 0x1d, 0x15, 0x15, 0x1f, 0x0e, 0x00,              'e
  0x00, 0x20, 0x64, 0x44, 0x7f, 0x3f, 0x04, 0x00,              'f
  0x00, 0x3e, 0x3f, 0x25, 0x25, 0x3d, 0x18, 0x00,              'g
  0x00, 0x07, 0x0f, 0x08, 0x08, 0x7f, 0x7f, 0x00,              'h
  0x00, 0x00, 0x01, 0x2f, 0x2f, 0x01, 0x00, 0x00,              'i
  0x00, 0x00, 0x5e, 0x5f, 0x01, 0x07, 0x06, 0x00,              'j
  0x00, 0x11, 0x1b, 0x0e, 0x04, 0x7f, 0x7f, 0x00,              'k
  0x00, 0x00, 0x00, 0x7f, 0x7f, 0x00, 0x00, 0x00,              'l
  0x1f, 0x1f, 0x0c, 0x07, 0x0c, 0x1f, 0x1f, 0x00,              'm
  0x00, 0x0f, 0x1f, 0x18, 0x18, 0x1f, 0x1f, 0x00,              'n
  0x00, 0x0e, 0x1f, 0x11, 0x11, 0x1f, 0x0e, 0x00,              'o
  0x00, 0x18, 0x3c, 0x24, 0x24, 0x3f, 0x3f, 0x00,              'p
  0x03, 0x01, 0x3f, 0x3f, 0x24, 0x3c, 0x18, 0x00,              'q
  0x00, 0x0c, 0x1c, 0x10, 0x10, 0x1f, 0x1f, 0x00,              'r
  0x00, 0x12, 0x15, 0x15, 0x15, 0x15, 0x09, 0x00,              's
  0x00, 0x08, 0x08, 0x3f, 0x3f, 0x08, 0x08, 0x00,              't
  0x00, 0x1f, 0x1f, 0x01, 0x01, 0x1f, 0x1e, 0x00,              'u
  0x00, 0x0c, 0x0e, 0x03, 0x03, 0x0e, 0x0c, 0x00,              'v
  0x1e, 0x1f, 0x01, 0x0f, 0x01, 0x1f, 0x1e, 0x00,              'w
  0x00, 0x11, 0x1b, 0x0e, 0x0e, 0x1b, 0x11, 0x00,              'x
  0x00, 0x1e, 0x1f, 0x05, 0x05, 0x1d, 0x18, 0x00,              'y
  0x00, 0x00, 0x19, 0x1d, 0x17, 0x13, 0x00, 0x00,              'z
  0x00, 0x41, 0x41, 0x77, 0x3e, 0x08, 0x00, 0x00,              '{
  0x00, 0x02, 0x06, 0x0c, 0x18, 0x30, 0x20, 0x00,              '\
  0x00, 0x00, 0x08, 0x3e, 0x77, 0x41, 0x41, 0x00,              '}
  0x00, 0x10, 0x08, 0x18, 0x10, 0x18, 0x08, 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 Test_Display()                                'Turn on all LEDS'
'===============================================================================
Max_Write(0x0F, 0x01, 0x01)
Max_Write(0x0F, 0x00, 0x00)
End sub

'===============================================================================
Sub Procedure Clear_Leds()                                   'Turn off all Leds
'===============================================================================
For Col = 1 TO 8
   Max_Write(Col, 0x00, 0x00)
   Delay_ms(2)
Next  Col
End sub

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

'===============================================================================
Sub Procedure Write_Display()
'===============================================================================
   'Send data from Buffer to Displays
      For Col = 1 to 8
       Max_Write(Col, Buffer[0 + (Col - 1)], Buffer[8 + (Col - 1)])
   Next Col
End Sub

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

'===============================================================================
  OSCCON     = %01110000                                      '8Mhz internal
  ANSELB     = %00000000                                      'Port B digital
  TRISB      = %00000000
  SPI1_Init()
  Max7219_Init()
  Clear_Leds()

  Buffer = "                "                                 'Clear Buffer
  Index = 0                                                   'Index to 0
  Str = " ! #$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_'abcdefghijklmnopqrstuvwxyz{|}~"

  'Loop ------------------------------------------------------------------------
  While True

    CharX = Read_Str()                                        'Read Character                                                                'Into buffer
    For y1 = 7 to 0 step -1                                   'Into buffer
       Buffer[0] = Font[((CharX - 0x20) <<3) + y1]

       For x1 = 15 to 1 step -1                               'Sroll 1 pos left
          Buffer[x1] = Buffer[x1 - 1]
       Next x1
       Buffer[0] = 0x00                                       'Clean first byte

       Write_Display()
       Delay_ms(50)
    Next y1

 Wend
 End.
Fouten zijn het bewijs dat je het probeert..
Arco

Special Member

Mooi dat het gelukt is. (ik heb geen max7219, dus kon 't ook niet proberen...)
Meestal is het 't simpelste om te vergelijken tussen wat er zou moeten gebeuren, en wat er werkelijk gebeurt.
(vaak kun je dan wel herleiden wat er mis gaat...)

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Bavelt

Golden Member

Dat klopt.
Soms heb ik wel eens na lang turen op de software: "Dit moet toch werken?". Maar als het dat toch niet doet, dan helpt het inderdaad om gewoon op een stuk papier stap-voor-stap uit tekenen wat er nu écht gebeurt. ;)

Fouten zijn het bewijs dat je het probeert..
Arco

Special Member

De UART gebruiken voor debuggen kan ook heel handig zijn om te laten zien / volgen wat er gebeurt... (ik gebruik meestal HTerm )

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com

Bavelt, kun je mij eens de 2 lijnen van de CONFIG1 & 2 posten, die staan niet in de code listing.
En top dat je uw probleem gevonden hebt _/-\o_

LDmicro user.
Arco

Special Member

MikroBasic heeft geen CONFIG regels, wordt in de IDE geregeld (dat wordt dan een screendump... ;) )
Ik heb wel een paar keer om mogelijkheid van zetten CONFIG in de code in te bouwen gevraagd, men zou er over denken. Maar tot nu toe nog niet...
(is vooral handig zoals nu: met het plaatsen van code)

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com

Het is mij niet direct om de code zelf te doen maar om te zien of Mikrobasic alles juist zet betreffen de gebruikte frequentie, in dit geval intern 8MHz
Ik ben deze week eens aan het spelen geweest met een 16F1827 op 32MHz en de afwijking van de interne oscillator.
Het is eerder nieuwsgierigheid ;)

edit: ik heb het in Mikrobasic zelf al gevonden, die heeft een editor hiervoor als je een NEW project opstart.
Vandaar dat je beter ook de projectfile post als je Mikrobasic programma's post voor CO'ers die niet zo vertrouwd zijn met die taal.

[Bericht gewijzigd door MGP op zondag 12 januari 2020 15:24:58 (29%)

LDmicro user.
Arco

Special Member

Daarom heb ik (en vele anderen) gevraagd voor de CONFIG mogelijkheid in de sourcecode. Is veel makkelijker met delen van code...
Clock frequentie wordt trouwens met OSCCON geset...

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Bavelt

Golden Member

De UART gebruiken voor debuggen kan ook heel handig zijn om te laten zien / volgen wat er gebeurt... (ik gebruik meestal HTerm )

Ik zocht inderdaad ook al naar een methode om te kunnen debuggen. Met breakpoints en zo.
In Visual Basic.NET maak ik daar veel gebruik van en is bij het fout zoeken in omvangrijke programma's onontbeerlijk.

Tot nu toe gebruikte ik in MikroBasic soms een ledje dat je aan of uit zet, om te kijken of een routine wel op de plek komt waar je het wilt.
Maar mooier is natuurlijk om de waarden 'live' te kunnen zien.
Met UART en MikroBasic heb ik geen ervaring, ga ik dus ook maar eens mee aan de gang.

Fouten zijn het bewijs dat je het probeert..
Bavelt

Golden Member

Vandaar dat je beter ook de projectfile post als je Mikrobasic programma's post voor CO'ers die niet zo vertrouwd zijn met die taal.

Bij deze..

Fouten zijn het bewijs dat je het probeert..
Bavelt

Golden Member

Wat ik zelf daarnaast ook wel eens wil proberen is om de tekst in te voeren via Bluetooth (vanaf bv een Smartphone). Bij de Arduino wordt daar blijkbaar de HC 05 Bluetooth module voor gebruikt.

Met het risico dat ik een verouderd type bestel, is dit nog steeds gangbaar?

Ik zie dat er ook een JDY-31 is. (Is goedkoper).

Fouten zijn het bewijs dat je het probeert..
Arco

Special Member

Ik gebruik de ESP32-WROOM32D. (tot nu toe alleen voor Wifi gebruikt, maar kan ook Bluetooth...)

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Bavelt

Golden Member

Dit is een redelijk uitgebreide zie ik, (met veel pennen). Hij kan blijkbaar WIFI, Bluetooth en kan met I2C werken zie ik.

Je moet er dan wel een adapter bij hebben, die prik je niet even op een breadboard.

Hopelijk is dat ding niet te ingewikkeld...

Daarentegen kosten ze allebei vrij weinig Ik denk dat ik ze beide maar bestel.

Fouten zijn het bewijs dat je het probeert..
Arco

Special Member

Zijn er ook op een printje, ik heb er zelf een gemaakt:

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Bavelt

Golden Member

Wederom om te delen met geïnteresseerden:

Hier is een voorbeeld van een lichtkrant met 6 Matrix LED's, 8*8.
Deze LEDS zitten aan elkaar vast en zijn horizontaal geschakeld. Dat vergt een iets andere wijze van programmeren (rijen ipv kolommen).

MicroController: PIC 16F1847
Taal:MikroBasic
Oscillator: intern 16Mhz

Fouten zijn het bewijs dat je het probeert..
Bavelt

Golden Member

Zijn er ook op een printje, ik heb er zelf een gemaakt:

Ik heb er ook eentje besteld, compleet met printje.
Ook de JDY-31 er maar bij gedaan.

Fouten zijn het bewijs dat je het probeert..
Bavelt

Golden Member

De UART gebruiken voor debuggen kan ook heel handig zijn om te laten zien / volgen wat er gebeurt... (ik gebruik meestal HTerm )

Is Hterm nu makkelijk te gebruiken in combinatie met MikroBasic en de Pickit 3 en PICKIT V3.10?

Als ik even naar het Arduinoboardje kijk met de UNO, dan gaat het heel makkelijk om de output van een sketch op de PC als monitor te zien.
Zou mooi zijn als het op die manier ook met MB te regelen zou zijn.
Of moeten er dan heel ingewikkelde dingen gebeuren?

Fouten zijn het bewijs dat je het probeert..
Arco

Special Member

Ik begrijp niet goed wat de Pickit er mee te maken heeft?
Je stuurt gewoon wat je wilt zien via de uart naar je pc...

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Bavelt

Golden Member

Ok, ik was wat geïnspireerd door de Arduino UNO R3. Het dingetje is met één USB kabel verbonden met de PC. Je programmeert de controller, het ding geeft de voeding en de output is meteen zichtbaar op het PC scherm.

Ik begrijp dat, zoals ik nu werk (programmeren met MikroBasic en programmer Pickit) ik een extra USB kabel moet hebben naar een tweede USB poort.

En dat via UART aan te sturen. Toch?

Fouten zijn het bewijs dat je het probeert..
Arco

Special Member

Ah,

Jij wilt een debugger gebruiken, dat gaat niet met het standalone programma. (dat is een programmer, geen debugger)
Voor 'echt' debuggen kun je MikroICD gebruiken, of een COFF file exporteren en die in MPLAB gebruiken...

Ik stuur gewoon data via de UART naar de PC om te zien wat er gebeurt, de debugger gebruik ik nooit.

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Bavelt

Golden Member

Ik stuur gewoon data via de UART naar de PC om te zien wat er gebeurt, de debugger gebruik ik nooit.

Dat is ook wat ik wil. Bijvoorbeeld om de waardes van velden te tonen (Dat doe ik nu soms met ledjes).
Of 'reguliere' output. zoals bijvoorbeeld een I2C scanner, waarbij de gevonden waarden op het scherm worden getoond ipv een LCD aan te sluiten.
Of een klok, Temperatuur, etc.

Maar tussen de PIC en de USB zit dus 'iets'.

Daar heb ik totaal geen ervaring mee.

Fouten zijn het bewijs dat je het probeert..
Arco

Special Member

Je kunt in het Pickit2/3 programma in Tools de UART Tool kiezen, dat zou moeten werken (nooit geprobeerd)

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Bavelt

Golden Member

Voor zover ik het lees en begrijp uit publicaties, ondersteunt Pickit3 de UART tool niet (meer)
De Pickit2 wel.

Fouten zijn het bewijs dat je het probeert..
Bavelt

Golden Member

Ik ben nog weer even wat aan het stoeien met een lichtkrant.
Met 6 LED matrixen 8*8
Het werkt wel. Maar nu zat ik onlangs in een trein met een dergelijke lichtkrant (ook 8 * 8 Leds) en daar zag je de tekst zo mooi vloeiend lopen.
In mijn geval verloopt het toch wat 'schokkerig'. Je ziet de kolommen stuk voor stuk opschuiven. (tak-tak-tak). Wat zou een goede oplossing zijn om de tekst mooi te laten vloeien?
Het (MikroBasic) programma:

pic basic code:

 Program Lichtkrant_6D
'Display Matrix: 6 Elements LED 8 * 8, type 1088AS
'Processor: PIC16F1847

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

    Row        as Byte
    i1         as byte
    j1         as byte
    y1         as byte

    Str        as String[105]
    CharX      as Char
    Index      as Byte
    
Const Font 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,              '@
  0x66, 0x66, 0x66, 0x7e, 0x66, 0x66, 0x3c, 0x00,              'A
  0x3e, 0x66, 0x66, 0x3e, 0x66, 0x66, 0x3e, 0x00,              'B
  0x3c, 0x66, 0x06, 0x06, 0x06, 0x66, 0x3c, 0x00,              'C
  0x3e, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3e, 0x00,              'D
  0x7e, 0x06, 0x06, 0x3e, 0x06, 0x06, 0x7e, 0x00,              'E
  0x06, 0x06, 0x06, 0x3e, 0x06, 0x06, 0x7e, 0x00,              'F
  0x3c, 0x66, 0x76, 0x06, 0x06, 0x66, 0x3c, 0x00,              'G
  0x66, 0x66, 0x66, 0x7e, 0x66, 0x66, 0x66, 0x00,              'H
  0x3c, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00,              'I
  0x1c, 0x36, 0x36, 0x30, 0x30, 0x30, 0x78, 0x00,              'J
  0x66, 0x36, 0x1e, 0x0e, 0x1e, 0x36, 0x66, 0x00,              'K
  0x7e, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x00,              'L
  0xc6, 0xc6, 0xc6, 0xd6, 0xfe, 0xee, 0xc6, 0x00,              'M
  0xc6, 0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0x00,              'N
  0x3c, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x00,              'O
  0x06, 0x06, 0x3e, 0x66, 0x66, 0x66, 0x3e, 0x00,              'P
  0x60, 0x3c, 0x76, 0x66, 0x66, 0x66, 0x3c, 0x00,              'Q
  0x66, 0x36, 0x1e, 0x3e, 0x66, 0x66, 0x3e, 0x00,              'R
  0x3c, 0x66, 0x60, 0x3c, 0x06, 0x66, 0x3c, 0x00,              'S
  0x18, 0x18, 0x18, 0x18, 0x18, 0x5a, 0x7e, 0x00,              'T
  0x7c, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00,              'U
  0x18, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00,              'V
  0x63, 0x77, 0x7f, 0x6b, 0x63, 0x63, 0x63, 0x00,              'W
  0xc6, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0xc6, 0x00,              'X
  0x18, 0x18, 0x18, 0x3c, 0x66, 0x66, 0x66, 0x00,              'Y
  0x7e, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x7e, 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               '~
  )

Dim BufferIn as Byte[6][8]
Dim Buffer   as Byte[6]

'===============================================================================
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

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

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

'===============================================================================
Sub Procedure Clear_Leds()                                   'Turn all Leds off
'===============================================================================
FOR Row = 1 TO 8
   Max_Write(Row, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
   delay_ms(2)
NEXT Row
End sub

''===============================================================================
Sub Procedure Write_Display()                  'Inhoud schrijven naar Displays
''===============================================================================
For Row = 1 to 8
       Buffer[0] = BufferIn[0] [Row - 1]
       Buffer[1] = BufferIn[1] [Row - 1]
       Buffer[2] = BufferIn[2] [Row - 1]
       Buffer[3] = BufferIn[3] [Row - 1]
       Buffer[4] = BufferIn[4] [Row - 1]
       Buffer[5] = BufferIn[5] [Row - 1]
       Max_Write(Row, Buffer[0], Buffer[1], Buffer[2], Buffer[3], Buffer[4], Buffer[5])
       Delay_ms(1)
    Next Row
End Sub

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

'===============================================================================
Sub Procedure Shift()
'===============================================================================

For i1 = 5 to 0 step -1
   For j1 = 0 to 7
      BufferIn[i1][j1].0 = BufferIn[i1][j1].1
      BufferIn[i1][j1].1 = BufferIn[i1][j1].2
      BufferIn[i1][j1].2 = BufferIn[i1][j1].3
      BufferIn[i1][j1].3 = BufferIn[i1][j1].4
      BufferIn[i1][j1].4 = BufferIn[i1][j1].5
      BufferIn[i1][j1].5 = BufferIn[i1][j1].6
      BufferIn[i1][j1].6 = BufferIn[i1][j1].7
      if i1 > 0 then BufferIn[i1][j1].7 = BufferIn[i1-1][j1].0 else BufferIn[0][j1].7 = 0  end if
 Next j1
      Write_Display()
Next i1
End Sub

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

'===============================================================================
  OSCCON     = %01111000                                      '16Mhz internal
  ANSELB     = %00000000                                      'Port B   digital
  TRISB      = %00000000                                      'Port B    Output

  SPI1_Init()
  Max7219_Init()

  Clear_Leds()

  Str = " ! #$%&'()*+,-./0123456789:;<=>? 
 @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_'abcdefghijklmnopqrstuvwxyz{|}~"
   
   Index = 0
'
'   'Loop ----------------------------------------------------------------------
    While true
    Write_Display()

    For y1 = 0 to 7
      Shift()
    Next y1

     CharX = Read_Str()                                         'Read Character                                                                'Into buffer
      For y1 = 0 to 7                                           'Into buffer
        BufferIn[0][y1] = Font[((CharX - 0x20) <<3) + y1]
      Next y1

  Wend
  End. 
Fouten zijn het bewijs dat je het probeert..
Bavelt

Golden Member

Waarom mag dit niet in MikroBasic?

pic basic code:

 Dim Str as String [5] [105]

Ik wilde een array maken van 5 strings van 105 lang.

Wanneer de variabele byte is mag het wel..

Fouten zijn het bewijs dat je het probeert..