Mikrobasic, Interrupts en multiplexen


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.

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

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

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

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.

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?

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" - www.arcovox.com

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?

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" - www.arcovox.com

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.

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" - www.arcovox.com

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

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. 

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..

Normaal gebruik je daar Char voor (zelfde als string)

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

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

Als ik het goed heb is deze ESP32 Een developKit, á la de Arduino.
Maar is zo'n ding ook te gebruiken in combinatie met MikroBasic?

Is default gewoon een standalone tranceiver die je met uart aan kunt sturen...

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

Hebben we het wel over hetzelfde ding?

Ik lees hierover nl dingen als Arduino-sketches downloaden. Ledjes laten knipperen, etc

De ESP is alleen het blikken doosje, wat er nog meer voor frut op dat printje zit weet ik niet...

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

Dan heb ik de verkeerde besteld.. :S ik vermoeddee het al.
Op dit printje zit een ESP32, maar ook een chip/microcontroller waarmee je allerlei dingen kan doen, vergelijkbaar met de Arduino.

Een 'Developer Kit'

De chip die er op zit is een CP2102, USB to UART

En een AMS1117, Voltage regulator naar 3,3 V

KGE

Golden Member

Op 21 februari 2020 17:58:08 schreef Bavelt:
Dan heb ik de verkeerde besteld.. :S ik vermoeddee het al.
Op dit printje zit een ESP32, maar ook een chip/microcontroller waarmee je allerlei dingen kan doen, vergelijkbaar met de Arduino.

Een 'Developer Kit'

Kijk hier eens: https://randomnerdtutorials.com/installing-the-esp32-board-in-arduino-ide-windows-instructions/

De ESP32 is in de basis een UART gestuurd apparaat net als de voorganger ESP8266 maar het hart wordt gevormd door een zeer stevige microprocessor die je vanuit de Arduino IDE kunt programmeren net als de andere Arduino bordjes. En daarnaast heb je dan WiFi mogelijkheden.

Ik heb zojuist een test gedaan met de ESP32 i.c.m. de Arduino en ik krijg het inderdaad aan de praat: Een Wifi-scan en de resultaten worden keurig getoond op de monitor (PC-scherm).
Ik mnoest wel de baudrate terugbrengen van 115200 naar 9600 anders krijg je rare tekens op het scherm.

Dit ding werkt dus. Nu is de uitdaging om data (tekst) te versturen naar een PIC micro processor (lichtkrant) geprogrammeerd in MikroBasic.

Daar staat nl de tekst als een literal (string) in het flashgeheugen. Het leukste zo zijn om de tekst van een ander device (PC, laptop of Smartphone) naar de lichtkrant te brengen.

Ik heb nog geen ervaring met PIC en UART.

Ik moest wel de baudrate terugbrengen van 115200 naar 9600 anders krijg je rare tekens op het scherm.

Dit is inmiddels ook opgelost. Ik zag dat je de baudrate kunt instellen als een parameter bij de uitvoer. Die moet matchen wat in het programma staat.
Dan loopt het goed.

Wel krijg ik na compileren steeds meldingen van "ongeldige biblitotheek gevonden" en dat er geen header files zijn gevonden die bij de sketch horen.
Maar blijkbaar zijn dat waarschuwingen; het programma loopt er niet minder om.

KGE

Golden Member

Je zou ook het hele MikroBasic programma kunnen omzetten naar Arduino code en alleen maar op de ESP32 laten draaien, die is vele malen sneller dan de Atmega chippies.. Weet alleen niet of je dan genoeg IO lijnen hebt.