help with the Operation LED panel 16x32 scan 1/4 P10 - hub75

[jam19857]

Hello good afternoon everyone, I found information about the P10 monocolor 16 x 32 led modules with ¼ scan; I found the following link:

https://ferhatyol.com/yazilim/p10-panel-kullanimi.html

I tried the code in a led module and it works fine, the compiler where they created the code is CCS 5.015.

I am trying to pass the code to proton ide and I have been able to get some functions working: line, circle, rectangle, invert screen, clear screen, brightness and put a pixel in a desired position.

Code Select Expand

Device = 18F26K22
Declare Xtal = 40
Declare Create_Coff On
'Declare Float_Display_Type = Fast           ' Tell the compiler to use the faster and more accurate Float to ASCII converter
Declare Watchdog Off

Declare HSerout_Pin = PORTC.6
Declare Hserial_Baud = 9600

Declare CCP1_Pin PORTC.2

TRISB.0 = 0
TRISB.1 = 0
TRISC.2 = 0
PORTB = 0

Include "Multi_RAM_Byte_Array.inc"
Include "Panel P10.inc"

; T0CON: TIMER 0 CONTROL REGISTER
T0CONBITS_TMR0ON = 1  ; "1" HABILITA TIMER0, "0" DETIENE EL TIMER0
T0CONBITS_T08BIT = 0  ; "1" CONFIGURA EL TIMER0 A 8 BITS; "0" CONFIGURA EL TIMER0 A 16 BITS
T0CONBITS_T0CS   = 0  ; "1" TRANASISICON DEL PIN EXTERNO T0CKI; "0" CICLO DE RELOJ INTERNO (CLKOUT)
T0CONBITS_T0SE   = 1  ; "1" INCREMENTA EN FLANCO DE ALTO A BAJO SOBRE EL PIN T0CKI; "0" INCREMENTA EN FLANCO DE BAJO A ALTO SOBRE EL Pin T0CKI
T0CONBITS_PSA    = 0  ; "1" PRESCALER NO ASIGNADO, EL TIEMPO DE RELOJ ES UN PUENTE; "0" SE ASIGNA PREESCALER A LA SALIDA.
T0CONBITS_T0PS2  = 1  ;PRESCALER
T0CONBITS_T0PS1  = 0  ; 111 = 1:256 ; 110 = 1:128 ; 101 = 1:64 ; 100 = 1:32 ; 011 = 1:16 ; 010 = 1:8 ; 001 = 1:4 ; 000 = 1.2
T0CONBITS_T0PS0  = 0

;RCON: RESET CONTROL REGISTER
RCONBITS_IPEN    = 1   ; "1" HABILITA LA PRIORIDAD DE LOS NIVELES CATIVOS DE INTERRUPCION;"0" DESHABILITA LA PRIORIDAD DE LOS NIVELES CATIVOS DE INTERRUPCION
;CUANDO IPEN (PRIORIDAD DE INTERRUPCIONES)
;INTCON: INTERRUP CONTROL REGISTER
INTCONBITS_GIE   = 1   ; IPEN = 0
                       ; "1" HABILITA TODAS LAS INTERRUPCIONES NO ENMASCARADAS; "0" DESHABILITA TODAS LAS INTERRUPCIONES INCLUYENDO PERIFERICOS
                       ; IPEN = 1
                       ; "1" HABILITA TODAS LAS INTERRUPCIONES DE ALTA PRIORIDAD; "0" DESHABILITA TODAS LAS INTERRUPCIONES INCLUYENDO LAS DE BAJA PRIRORIDAD
INTCONBITS_PEIE  = 1   ; IPEN = 0
                       ; "1" HABILITA TODAS LAS INTERRUPCIONES NO ENMASCARADAS DE PERIFERICOS; "0" DESHABILITA TODAS LAS INTERRUPCIONES DE PERIFERICOS
                       ; IPEN = 1
                       ; "1" HABILITA TODAS LAS INTERRUPCIONES DE BAJA PRIORIDAD; "0" DESHABILITA TODAS LAS INTERRUPCIONES DE BAJA PRIORIDAD
INTCONBITS_TMR0IE  = 1 ; "1" HABILITA LA INTERRUPCION DE DESBORDAMIENTO DEL TMR0; "0" DESHABILITA LA INTERRUPCION DE DESBORDAMIENTO DEL TMR0

;INTCON2 : INTERRUP CONTROL 2 REGISTER
INTCON2BITS_TMR0IP = 1 ; " 1" HABILITA ALTA PRIORIDAD DE LA INTERRUPCION DE DESBORDAMIENTO TMR0; "0" HABILITA BAJA PRIORIDAD DEL DESBORDAMIENTO DEL TMR0


TMR0L = 0
TMR0H = 0

; para el calculo de DEL TIMER 0 PARA DESBORDAMIENTO
Dim TIEMPO As Word
Dim TIMER_INT As Float
Dim FOSC As Dword
Dim PRESCALER As Word
Dim VALOR_1 As Float
Dim VALOR_2 As Float
Dim CARGA_TIMER As Word

TIEMPO = 800             ; TIEMPO DE INTERRUPCION DESORDAMIENTO
TIMER_INT = TIEMPO/1000000  ; PARA MILISEGUNDOS (1000); PARA MICROSEGUNDOS (1000000)
FOSC = 40000000           ; 20 MhZ
PRESCALER = 32         ; PRESCALADOR ASIGNADO

VALOR_1 = FOSC*TIMER_INT
VALOR_2 = 4*PRESCALER

'CARGA_TIMER = 256 - (VALOR_1 / VALOR_2) ; VALOR CALCULADOR PARA DESBORDAMIENTO DE TIMER 8 BITS
CARGA_TIMER = 65536 - (VALOR_1 / VALOR_2) ; VALOR CALCULADOR PARA DESBORDAMIENTO DE TIMER 16 BITS

TMR0L = CARGA_TIMER.LowByte ;CARGA_TIMER
TMR0H = CARGA_TIMER.HighByte 
'HSerOut [Hex CARGA_TIMER,13]
'HSerOut [Hex CARGA_TIMER.HighByte,13]
'HSerOut [Hex CARGA_TIMER.LowByte,13]

; VARIABLES DEL PROGRAMA
Dim int_syc As Byte
Dim i As Byte
Dim w As Byte
Dim x3 As Byte
Dim x As Byte
Dim z As Byte
'Dim myarray As Byte


Symbol LED = PORTB.0
Symbol LED2 = PORTB.1

int_syc = 0
i  = 0
w  = 0
x3 = 0

For x = 1 To 8
      LED = 1 ;  // enciende led
      DelayMS 50
      LED = 0
      DelayMS 50
Next x

High LED ;  // enciende led

On_Hardware_Interrupt GoTo Isr_TIMER0

Set_Brightness(10);   //Da brillo.
clear_display(0)


Main:
'''      led = 1
'invert_screen()
'   
    PutPixel(0,0,1)
    PutPixel(0,15,1)
    PutPixel(31,0,1)
    PutPixel(31,15,1)
    PutPixel(15,8,1)
    DelayMS 500
    clear_display(0)
    Rectangle(14,6,17,9,0);
    DelayMS 600
    clear_display(0);
    Rectangle(11,3,20,12,0);
    DelayMS 600;
    clear_display(0);
    Rectangle(8,0,23,15,0);
    DelayMS 600;
    clear_display(0);
    Rectangle(14,6,17,9,1);
    DelayMS 600;
    clear_display(0);
    Rectangle(11,3,20,12,1);
    DelayMS 600;
    clear_display(0);
    Rectangle(8,0,23,15,1);
    DelayMS 1000;
    clear_display(0);
    Circulo(16,8,2,0);
    DelayMS 600;
    clear_display(0);
    Circulo(16,8,4,0);
    DelayMS 600;
    clear_display(0);
    Circulo(16,8,7,0);
    DelayMS 600;
    clear_display(0);
    Circulo(16,8,2,1);
    DelayMS 600;
    clear_display(0);
    Circulo(16,8,4,1);
    DelayMS 600;
    clear_display(0);
    Circulo(16,8,7,1);
    invert_screen()
    DelayMS 1000;
    clear_display(0);
    DelayMS 100;
    Linea(0,0,31,15,1);
    DelayMS 600;
    Linea(0,15,31,0,1);
    DelayMS 600;
    Linea(5,0,8,15,1); 
    DelayMS 600;
    Linea(31,8,0,4,1);
    DelayMS 600;
    Linea(29,0,10,15,1);
    DelayMS 600;
    Linea(31,13,0,8,1);
    DelayMS 1000;
   
    clear_display(0); 
   
    BarTest()
    clear_display(0);
   
GoTo Main
End     


Isr_TIMER0:
        Context Save
            If INTCONBITS_TMR0IF = 1 Then ; "1" BANDERA DE INTERRUPCION DEL REGISTRO TMR0 HA DESBORDADO; "0" EL REGISTRO DE TMR0 NO SE HA DESBORDADO
'                INTCONBITS_TMR0IF = 0
'                TMR0L = CARGA_TIMER.LowByte ;CARGA_TIMER
'                TMR0H = CARGA_TIMER.HighByte
        '            HSerout [dec PRELOAD,13]
        '            delayms 200
'                led = 1   
                 
                Select int_syc  ; Cada 800us Saltar a la siguiente línea
               
                        Case 0
                                write_data(int_syc) : PinA = 0 : PinB  = 0 : LATCH = 1 : LATCH = 0     
                        Case 1
                                write_data(int_syc) : PinA = 1 : PinB  = 0 : LATCH = 1 : LATCH = 0 
                        Case  2
                                write_data(int_syc) : PinA = 0 : PinB  = 1 : LATCH = 1 : LATCH = 0 
                        Case 3
                                write_data(int_syc) : PinA = 1 : PinB  = 1 : LATCH = 1 : LATCH = 0                                                             
                 EndSelect             
       
                 int_syc = int_syc + 1     
                     
                 If int_syc > 3 Then
                     int_syc = 0
                 EndIf
'                 INTCONBITS_TMR0IF = 0
'                 TMR0L = CARGA_TIMER.LowByte ;CARGA_TIMER
'                 TMR0H = CARGA_TIMER.HighByte
            EndIf     
            INTCONBITS_TMR0IF = 0
            TMR0L = CARGA_TIMER.LowByte ;CARGA_TIMER
            TMR0H = CARGA_TIMER.HighByte                         
        Context Restore

Proc write_data(row_adr As Byte)
        Dim i0 As Byte
        Dim J0 As Byte
        Dim k0 As Byte
        Dim cont As Byte
        Dim myarray As Byte
       
        i0 = 0
        j0 = 0
        k0 = 3
       
        While k0 <> 255
               j0 = 15 - k0                    ; Carga hacia la izquierda.
               For i0 = 0 To 3 Step 1           ; Se están llenando las líneas.
                   myarray = Read_MultiByteArray display_ram,[j0, row_adr]
                   SHOut PinData, PinSCK, MsbFirst,[myarray\8]
                   j0 = j0 - 4;
               Next i0
               k0 = k0 - 1
        Wend
EndProc
The functions in proton ide, teh name its Panel P10.inc :

Code Select Expand

Include "Multi_RAM_Byte_Array.inc"

TRISC = 0
PORTC = 0

Symbol PinA    =  PORTC.0
Symbol PinB    =  PORTC.1
'Symbol PinOE   =  PORTC.4                    ;//OE=0 Display OFF, OE=1 Display On
Symbol LATCH   =  PORTC.4                    ;//
Symbol PinSCK  =  PORTC.3                   ;//Spi Clock Hattý
Symbol PinData =  PORTC.5                     ;//Spi Data Hattý
'Symbol PWM_Pin =  PORTC.2                     ;//

''//       _____
''// PWM__|     \
''// OE___| And  }---- Disp_Enable
''//      |_____/     
''//
''//  P10 Led Board
''//      1     2
''// OE  --|oo|-- A
''// GND --|oo|-- B
''// GND --|oo|--
''// GND --|oo|-- SCK
''// GND --|oo|-- LATCH
''// GND --|oo|-- DATA
''// GND --|oo|--
''// GND --|oo|--
''//     15    16
''//
'#define Font1H   8
'#define Font2H   12
'#define Font3H   14
'#define Font4H   16
'#define Panel     1                        //P10 Panel Sayýsý
'#define RIGHT     0                        //
'#define LEFT      1                        //
'#define WIDTH     31
'#define HEIGHT    15
Symbol DobleFila = 0 ;//"1" para doble fila y "0" para una sola fila
Symbol ModulosWidth = 1 ; //numero de modulos que tiene a lo largo de su Letrero
Symbol HEIGHT = 15
Symbol BytePorMod = 4
Symbol TotalDeModulos = 1;
Symbol BytesTotal =  BytePorMod * TotalDeModulos  ;                // numero total de modulos de su letrero
Symbol BytesFila = BytePorMod * ModulosWidth
'Dim bit_test As Byte
Symbol GrupFila = BytePorMod * TotalDeModulos  ;// cada grupo pertence al IC 74HC595


Create_MByteArray(display_ram,16,4)                    ' Create a 2 dimensional Byte array 16 columns by 4 rows
Dim Text[100] As Byte =""
Dim imageBuffer[64] As Byte

''/*******************************************************************************
''*   Función de limpieza de pantalla                                            *
''*   Parameter:    fill                                                         *
''*   Return:                                                                    *
''*******************************************************************************/
Proc clear_display (fillx As Bit)
    Dim i0 As Byte
    Dim j0 As Byte
    Dim fdata As Byte
   
    i0 = 0
    j0 = 0
    fdata = 0
   
    If fillx = 1 Then
       fdata = 0x00
    Else
       fdata = 0xFF
    EndIf
   
    For i0 = 0 To 3 Step 1
        For j0 = 0 To 15 Step 1
            Write_MultiByteArray display_ram, [j0,i0], fdata
        Next j0
    Next i0

EndProc

''/*******************************************************************************
''*   Función de ajuste de brillo                                                *
''*   Parameter:    value (0-255)                                                *
''*   Return:                                                                    *
''*******************************************************************************/
Proc Set_Brightness(value As Byte)
        HPWM 1, value, 1000 
EndProc


''/*******************************************************************************
''*   Función de píxel                                                           *
''*   Parameter:    Xpos, Ypos, fill                                             *
''*   Return:                                                                    *
''*******************************************************************************/
Proc PutPixel(Xpos As Byte, Ypos As Byte, fillx As Bit)
    Dim y1 As Byte
    Dim x1 As Byte
    Dim y2 As Byte
    Dim x2 As Byte
    Dim temp As Byte
    Dim Xran As Word
    Dim Yran As Word
   
    Xran = Xpos
    Yran = Ypos
    temp = 0
         
    y1 = Yran //4
    y2 = Yran / 4
    x1 = Xran //8;   
    x2 = Xran / 8;
   
    If fillx = 1 Then  ; iluminar punto
       
        temp = Read_MultiByteArray display_ram, [(y2*4) + x2, y1]   ; El valor en RAM se almacena en caché.
        Write_MultiByteArray display_ram, [(y2*4) + x2, y1],(temp & (255-(128 >> x1)))    ; El bit x se establece en 0

    Else     ;//Eliminar o apagar punto

        temp = Read_MultiByteArray display_ram, [(y2*4)+x2, y1]       ; El valor en RAM se almacena en caché.
        Write_MultiByteArray display_ram, [(y2*4) + x2, y1],(temp | (128 >> x1))          ; El bit x se establece en 1   

    EndIf
   
EndProc

''/*******************************************************************************
''*   Función de inversión de pantalla                                                 *
''*   Parameter:                                                                 *
''*   Return:                                                                    *
''*******************************************************************************/
Proc invert_screen ()
     Dim i0 As Byte
     Dim j0 As Byte
     Dim myarray As Byte
     
     i0 = 0
     j0 = 0
     
     For i0 = 0 To 3 Step 1
           For j0 = 0 To 15 Step 1
''           display_ram[j][i] =~ display_ram[j][i];  //El valor en el caché no se vuelve a escribir   
             myarray = Read_MultiByteArray display_ram, [j0, i0]
             myarray = ~myarray
             Write_MultiByteArray display_ram, [j0, i0],myarray;  //El valor en el caché no se vuelve a escribir     
           Next j0
     Next i0
     
EndProc

''''/*******************************************************************************
''''*   Función de lectura de píxeles                                              *
''''*   Parameter:    Xpos, Ypos                                                   *
''''*   Return: value                                                              *
''''*******************************************************************************/
'''Proc Getpixel(Xpos As Byte, Ypos As Byte),Bit
'''       Dim y1 As Byte
'''       Dim x1 As Byte
'''       Dim y2 As Byte
'''       Dim x2 As Byte
'''       Dim temp As Byte
'''       Dim value As Byte
       
'''       y1 = 0
'''       x1 = 0
'''       y2 = 0
'''       x2 = 0
'''       temp = 0
'''       value = 0
       
'''       y1 = Ypos//4;
'''       y2 = Ypos/4;
'''       x1 = Xpos//8; 8   
'''       x2 = Xpos/8;  8
       
'''       Write_MultiByteArray display_ram, [(y2*4)+ x2, y1], temp; //El valor en RAM se almacena en caché.
'''       value = 1-(0x80 & temp << x1 )/128;   //El bit en la dirección Ram se está devolviendo
'''       Result = value
       
'''EndProc


''/*******************************************************************************
''*   Función de dibujo lineal                                                     *
''*   Parameter:    x1, x2, y1, y2, fill                                         *
''*   Return:                                                                    *
''*******************************************************************************/

Proc Linea(x1 As Byte, y1 As Byte, x2 As Byte, y2 As Byte, fillx As Bit)

        Dim addx As Word
        Dim addy As Word
        Dim P0 As Word
        Dim i0 As Word
        Dim dy As Word
        Dim dx As Word
        Dim diff As Word
       
        addx = 1
        addy = 1
       
            If x2 > x1 Then
                    dx = x2 - x1;
                Else
                    dx = x1 - x2;
                    addx = -1;
            EndIf
         
            If y2 > y1 Then
                   dy = y2 - y1;
                Else
                    dy = y1 - y2;
                    addy = -1;
            EndIf
           
            If dx >= dy Then
                     dy   = dy*2
                      P0   = dy - dx
                     diff =  P0 - dx
                 
                      For i0 = 0 To dx Step 1
                     
                         PutPixel(x1, y1, fillx)
               
                         If P0 < 0 Then
                            P0 = P0 + dy
                            x1 = x1 + addx
                         Else
                            P0  = P0 + diff
                            x1 = x1 + addx
                            y1 = y1 + addy
                        EndIf
                      Next i0
            Else
                     dx = dx*2
                     P0 = dx - dy
                     diff = P0 - dy

                    For i0 = 0 To dy Step 1
                       
                        PutPixel(x1, y1, fillx);

                        If P0 < 0 Then
                            P0 = P0 + dx
                            y1 = y1 + addy
                        Else
                            P0 = P0 + diff
                            x1 = x1 + addx
                            y1 = y1 + addy
                        EndIf   
                    Next i0
            EndIf
EndProc

''/*******************************************************************************
''*   Función de dibujo de rectángulo                                               *
''*   Parameter:    x1, x2, y1, y2, fill                                         *
''*   Return:                                                                    *
''*******************************************************************************/
Proc Rectangle(x1 As Byte, y1 As Byte, x2 As Byte, y2 As Byte, fillx As Bit)
      Dim i1    As Word
      Dim i2    As Word
      Dim xmin As Word
      Dim xmax As Word
      Dim ymin As Word
      Dim ymax As Word
     
      If fillx = 1 Then
   
              If x1 < x2 Then
                 xmin = x1
                 xmax = x2
              Else
                 xmin = x2
                 xmax = x1
              EndIf
   
              If y1 < y2 Then
                 ymin = y1;
                 ymax = y2;
              Else
                 ymin = y2;
                 ymax = y1;
              EndIf
   
    ''      for(; xmin <= xmax; ++xmin)
              For i1 = xmin To xmax Step 1 
                     For i2 = ymin To ymax Step 1
                        PutPixel(i1, i2, 1)
                     Next i2
              Next i1
      Else
              Linea(x1, y1, x2, y1, 1)
              Linea(x2, y1, x2, y2, 1)
              Linea(x2, y2, x1, y2, 1)
              Linea(x1, y2, x1, y1, 1)
      EndIf
EndProc

''/*******************************************************************************
''*   Función de dibujo circular                                                    *
''*   Parameter:    x, y, Size, fill                                             *
''*   Return:                                                                    *
''*******************************************************************************/
Proc Circulo(x0 As Byte, y0 As Byte, size As Byte, fillx As Bit)
        Dim a0 As SByte
        Dim b0 As SByte
        Dim P0 As SByte

        a0 = 0
        b0 = size
        P0 = 1 - size

        Do
              If fillx = 1 Then
                     Linea(x0 - a0, y0 + b0, x0 + a0, y0 + b0, 1)
                     Linea(x0 - a0, y0 - b0, x0 + a0, y0 - b0, 1)
                     Linea(x0 - b0, y0 + a0, x0 + b0, y0 + a0, 1)
                     Linea(x0 - b0, y0 - a0, x0 + b0, y0 - a0, 1)
              Else
                     PutPixel(a0 + x0, b0 + y0, 1)
                     PutPixel(b0 + x0, a0 + y0, 1)
                     PutPixel(x0 - a0, b0 + y0, 1)
                     PutPixel(x0 - b0, a0 + y0, 1)
                     PutPixel(b0 + x0, y0 - a0, 1)
                     PutPixel(a0 + x0, y0 - b0, 1)
                     PutPixel(x0 - a0, y0 - b0, 1)
                     PutPixel(x0 - b0, y0 - a0, 1)
              EndIf
             
              If P0 < 0 Then
                  P0 = P0 + 3 + 2*a0 ;P+= 3 + 2*a++;   
                  a0 = a0 + 1
              Else
                  P0 = P0 + 5 + 2*(a0 - b0) ;(;P+= 5 + 2*(a++ - b--);
                  a0 = a0 + 1
                  b0 = b0 - 1
              EndIf
        Loop While a0 <= b0
       
EndProc

''/*******************************************************************************
''*   Función de dibujo de gráfico de barras                                                  *
''*   Parameter:    x1, y1, x2, y2, Mode, Value                                  *
''*   Return:                                                                    *
''*******************************************************************************/
Proc Bargraph (x1 As Byte, y1 As Byte, x2 As Byte, y2 As Byte, hor As Bit, value As Byte)
        Dim w0 As Word
        Dim h0 As Word
        Dim a0 As Word
        Dim b0 As Word
        Dim barval As Word
       
        w0 = 0   
        h0 = 0
        a0 = 0
        b0 = 0
        barval = 0

        If x1 > x2 Then 
            w0 = x1 - x2
        EndIf
       
        If x1 < x2 Then
            w0 = x2 - x1 
        EndIf
       
        If y1 > y2 Then
            h0 = y1 - y2
        EndIf
       
        If y1 < y2 Then
            h0 = y2 - y1
        EndIf
       
        If value > 100 Then
            value = 100
        EndIf
       
        If hor = 1 Then ; La barra se creará verticalmente
''              barval=((int16)value*h)/100;
                barval=(value*h0)/100;
                For a0 = 0 To h0 Step 1
                      For b0 = 0 To w0 Step 1
                            If barval >= a0 Then
                                PutPixel(x1 + b0, 15 - a0 + y1, 1)
                            Else
                                PutPixel(x1 + b0, 15 - a0 + y1, 0)
                            EndIf
                      Next b0
                Next a0
        Else            ; La barra se creará horizontalmente
''              barval=((int16)value*w)/100;
                barval=(value*w0)/100   
                For a0 = 0 To w0 Step 1
                      For b0 = 0 To h0 Step 1
                            If barval >= a0 Then
                               PutPixel(x1 + a0, y1 + b0, 1)
                            Else
                               PutPixel(x1 + a0, y1 + b0, 0)
                            EndIf
                      Next b0
                Next a0
        EndIf

EndProc

''/*******************************************************************************
''*   Función de dibujo de test gráfico de barras                                                  *
''*   Parameter:    x1, y1, x2, y2, Mode, Value                                  *
''*   Return:                                                                    *
''*******************************************************************************/

Proc BarTest()
    Dim xstart As Byte
    Dim xend As Byte
    Dim w0 As Byte
    Dim i0 As Byte
         
    xstart = 0
    xend = 3
   
    clear_display(0);
    DelayMS 100
   
   
    For w0 = 0 To (6 * ModulosWidth + 1) Step 1
          For i0 = 1 To 100 Step 1
'            clear_display(0);
            Bargraph(xstart,0,xend - 1,HEIGHT,1,i0)
            DelayMS 4
          Next i0
          xstart = xstart + 4
          xend = xend + 4 
    Next w0
   
    xstart = 0
    xend = 3
   
    For w0 = 0 To (6 * ModulosWidth + 1) Step 1
          For i0 = 1 To 100 Step 1
'            clear_display(0);
            Bargraph(xstart,0,xend - 1,HEIGHT,1,100 - i0)
            DelayMS 4
          Next i0
          xstart = xstart + 4
          xend = xend + 4 
    Next w0

EndProc

I have not been able to configure the microcontroller with the internal oscillator of 64 MHz so that it works with the interruption of the timer of 800 micro seconds, in proteus it works but not physically, could you help me.

Could you please help me pass the three following functions to proton. I have tried to program them but I have not succeeded.

Code Select Expand

''/*******************************************************************************
''*   Función de cambio de línea                                                  *
''*   Parameter:    Line, ZeroBit                                                *
''*   Return:    OwerFlow                                                        *
''*******************************************************************************/
''int1 LineScroll(unsigned int Line, int1 ZeroBit){
''  unsigned int32 Tam=0;
''  unsigned int y1=Line%4;
''  unsigned int y2=Line/4;
''  int1 OwerFlow;
''  ZeroBit=1-Zerobit;
 
''  OwerFlow=(display_ram[(y2*4)][y1]/128)&0x01;
''  Tam=display_ram[(y2*4)][y1];
''  Tam=Tam<<8;
''  Tam=Tam+display_ram[(y2*4)+1][y1];
''  Tam=Tam<<8;
''  Tam=Tam+display_ram[(y2*4)+2][y1];
''  Tam=Tam<<8;
''  Tam=Tam+display_ram[(y2*4)+3][y1];
 
''  Tam=Tam<<1;
''  Tam=Tam+ZeroBit;
 
''  display_ram[(y2*4)  ][y1]=(int32)(Tam>>24)&0xFF;
''  display_ram[(y2*4)+1][y1]=(int32)(Tam>>16)&0xFF;
''  display_ram[(y2*4)+2][y1]=(int32)(Tam>>8)&0xFF;
''  display_ram[(y2*4)+3][y1]=(int32)(Tam&0xFF);
 
''  Return OwerFlow;
''}


'''/*******************************************************************************
'''*   Función de desplazamiento de texto Font1                                            *
'''*   Parameter:    Line, Speed, Fill                                            *
'''*   Return:                                                                    *
'''*******************************************************************************/
'''void ScrollTextFont1 (unsigned int Line, unsigned int speed,int1 fill){
'''  unsigned int a=0,b=0,i=0;
'''  unsigned int cdata=0;
'''  unsigned int16 delay=speed*20;
'''  int1 ZeroBit=0;
 
'''  While(Text[i]!='\0')
'''  {
'''    if(Line+Font1H-1>HEIGHT)Break;
'''    for(b=0;b<5;b++)
'''    {
'''      cdata=Font_5x7[Text[i]-32][b];
'''      for (a=0;a<8;a++)
'''      {
'''        ZeroBit=fill-(cdata>>a) & 0x01;
'''        LineScroll(Line+a,ZeroBit);
'''      }
'''      delay_Ms(210-delay);
'''    }
'''    for (a=0;a<8;a++)
'''    {
'''      LineScroll(Line+a,0);
'''    }
'''    delay_Ms(210-delay);
'''    i++;
'''  }
'''}

''/*******************************************************************************
''*   Función de impresión de texto Font1                                              *
''*   Parameter:    x, y, Fill                                                   *
''*   Return:                                                                    *
''*******************************************************************************/
''void DrawCharFont1(unsigned x, unsigned y, int1 fill){
''unsigned int a=0,b=0,i=0;
''unsigned int cdata=0;
''unsigned int clm=x,row=y;
     
''     While (Text[i]!='\0')
''     {
''      if(clm+5>WIDTH)  //Satýr sonuna gelindimi Bir Alt Satýra Geç
''      {
''        clm=0;         
''        row=row+8;
''        if(row+8>HEIGHT+1) break;
''      }
     
''      for(b=0;b<5;b++)
''      {
''       cdata=Font_5x7[Text[i]-32][b];
''       for(a=0;a<8;a++)
''       {
''          PutPixel(clm+b,row+a,(fill-(cdata>>a) & 0x01));
''       }
''      }
     
''      i++;
''      clm=clm+6;
''     } 
''}

I found a simulation on Facebook but I modified it to use it with the pic18f26k22.

https://es-la.facebook.com/technohalo/videos/p10-32x16-led-board-simulation-using-proteus/1712292695655553/

Files attached. I hope you could help me.

Modulo 16x32 P10.rar

[Pepe]

Modificado para oscilador interno de 64mhz

[Pepe]

Add LineScroll to library

[Pepe]

ADDED SINEWAVE AND WRITE TEXT

[jam19857]

Thank you very much Pepe, I tried the configuration for 64MHz and the microcontroller works fine, but the information to be displayed in the panel is incomplete, I was adjusting the overflow time and it does the same; unless some configuration is missing for handling high-speed arrays; It's a strange behavior, because at 40 Mhz it works fine.

I attach images, the one with the best definition is at 40Mhz and the ones that lose resolution are at 64Mhz


Thanks for your help with the Linescroll, Sinewave and Write text functions. I will try it.

You are good at programming you already know the proton compiler very well, thank you very much.

imagen del error.pdf

[Pepe]

Prueba agregar algunos nop en el pulso de latch

Code Select Expand

Isr_TIMER0:
        Context Save
            If INTCONBITS_TMR0IF = 1 Then                     ; "1" BANDERA DE INTERRUPCION DEL REGISTRO TMR0 HA DESBORDADO; "0" EL REGISTRO DE TMR0 NO SE HA DESBORDADO
                                         
                        wTimer = CARGA_TIMER
                
                Select int_syc  ; Cada 800us Saltar a la siguiente línea
               
                        Case 0
                                 write_data(int_syc) : PinA = 0 : PinB  = 0 : LATCH = 1: nop : LATCH = 0     
                        Case 1  
                                 write_data(int_syc) : PinA = 1 : PinB  = 0 : LATCH = 1: nop : LATCH = 0   
                        Case 2
                                 write_data(int_syc) : PinA = 0 : PinB  = 1 : LATCH = 1: nop : LATCH = 0   
                        Case 3 
                                 write_data(int_syc) : PinA = 1 : PinB  = 1 : LATCH = 1: nop : LATCH = 0                                                             
                 EndSelect             
       
                 Inc int_syc      
                     
                 int_syc = int_syc & 3

            EndIf     
            INTCONBITS_TMR0IF = 0
        Context Restore

y reemplaza write_data con

Code Select Expand

Symbol rp = 16 * Panel - 1
Symbol fp = 4 * Panel
     
Proc write_data(row_adr As Byte)
     
        Dim i0 As Byte = 0
        Dim J0 As Byte = 0
        Dim k0 As Byte = fp - 1
        Dim cont As Byte
        Dim myarray As Byte
       
       
        While k0 <> 255
               j0 = rp - k0                    ; Carga hacia la izquierda.
               For i0 = 0 To 3                 ; Se están llenando las líneas.
                   myarray = Read_MultiByteArray display_ram,[j0, row_adr]
                   SHOut PinData, PinSCK, MsbFirst,[myarray\8]
                   j0 = j0 - fp
               Next
               Dec k0
        Wend
EndProc

[Pepe]

text printing is added in the 2nd line, scrolltext and oe pin with brightness control

[pjdenyer]

Could you please use English then we can all follow

[jam19857]

Thanks Pepe, the compiler cannot find the scrolltext function and the change of the name of the oe pin for brightness control, could you please send it again.

[Pepe]

Uploaded again

[Pepe]

Added LoadImage and Writeimage

[Pepe]

I'm wrong section

[jam19857]

thanks pepe, I have some problems compiling the code on my computer, the code is 40Mhz because at 64hz it does strange things.

All functions work fine physically.

I don't know if the showimage function works, I couldn't compile in the software anymore.

[Pepe]

add this

Code Select Expand

'****************************************************************
'*  Name    : UNTITLED.BAS                                      *
'*  Author  : [select VIEW...EDITOR OPTIONS]                    *
'*  Notice  : Copyright (c) 2022 [select VIEW...EDITOR OPTIONS] *
'*          : All Rights Reserved                               *
'*  Date    : 25/11/2022                                        *
'*  Version : 1.0                                               *
'*  Notes   :                                                   *
'*          :                                                   *
'****************************************************************
GoTo img
img_1:
LData 0x55, 0x55, 0x55, 0x50
LData 0xff, 0xff, 0xff, 0xe0
LData 0x7f, 0xfb, 0xff, 0xf0
LData 0xff, 0xf5, 0xff, 0xe0
LData 0x7f, 0xee, 0xff, 0xf0
LData 0xff, 0xdf, 0x7f, 0xe0
LData 0x7f, 0xbf, 0xbf, 0xf0
LData 0xff, 0x7f, 0xdf, 0xe0
LData 0x7e, 0x00, 0x0f, 0xf0
LData 0xfe, 0xee, 0xef, 0xe0
LData 0x7e, 0xee, 0xef, 0xf0
LData 0xfe, 0x00, 0x0f, 0xe0
LData 0x7f, 0xff, 0xff, 0xf0
LData 0xff, 0xff, 0xff, 0xe0
LData 0x7f, 0xff, 0xff, 0xf0
LData 0xaa, 0xaa, 0xaa, 0xa0
img:
and compile your program with Positron, compiled with proton give error in while

[jam19857]

Hi Pepe, thanks for your support. I made some adjustments to the code. It works fine at 40Mhz.
At 64 MHz it does strange things, not all the data arrives.
Now I will try to do serial communication with interrupts and I will try to make the matrix expandable to use more modules.
I attach the code.

[Pepe]

I'm glad my contribution has been useful, good job

[jam19857]

Hello everyone. I'm trying to extend the use of this array; In CSS compiler it works for me but I can't pass the function to Proton 24 IDE.

Could you help me transfer it to proton 24, I can't make it work, I hope you can help me.
With this function you can scroll with several modules.

Code Select Expand

void LineScroll (unsigned int Line, int1 Zerobit)
{
   int y1=Line%4;//0
   int y2=Line/4;
   

         int1 bits[BytesTotal+1];
         int k,RamByte[BytesTotal+1];
         bits[GrupFila]=1-Zerobit; // inserta un bit <<< 1 a la fila
         
         For(k=0;k<BytesTotal;k++)
         {
            RamByte[k]= display_ram[(y2*GrupFila)+k][y1];     
         }
         For(k=0;k<BytesTotal;k++)
         {
            bits[k] = bit_test(RamByte[k],7);
            RamByte[k]=RamByte[k]<<1;
         }
         For(k=0;k<BytesTotal;k++)
         {
            display_ram[(y2*GrupFila)+k][y1] = RamByte[k]+bits[k+1];
         }
}

[Pepe]

probe this

Code Select Expand

Proc LineScroll( Lines As Word, ZeroBit As Bit)

    Dim y1 As Word = Lines // 4
    Dim y2 As Word = Lines / 4 
    Dim  bits[BytesTotal+1] As Byte = 0
    Dim  k0 As Word
    Dim RamByte[BytesTotal+1] As Byte = 0
           
         If Zerobit = 0 Then bits[GrupFila] = 1 ; // inserta un bit <<< 1 a la fila
         
         For k0 = 0 To BytesTotal
            RamByte[k0] = Read_MultiByteArray display_ram, [(y2*GrupFila)+k0,y1]
         Next
         
         For k0 = 0 To BytesTotal
           
            If RamByte[k0] & $80  <> 0 Then
                                            bits[k0] = 1
                                       Else
                                            bits[k0] = 0
            End If                                 
                                           
            RamByte[k0] = RamByte[k0] << 1
           
         Next
         
         For k0 = 0 To BytesTotal
         
            Write_MultiByteArray display_ram,[(y2*GrupFila)+k0 ,y1],(RamByte[k0] | bits[k0+1])
           
         Next
EndProc



[jam19857]

Thanks Pepe, I already checked it, just like this one they don't work, I made some changes and the scroll worked, I've physically tested it with 2 modules and it works fine.

Code Select Expand

Proc LineScroll( Lines As Byte, ZeroBit As Bit), Bit

        Dim y1 As Word = Lines // 4
        Dim y2 As Word = Lines / 4
        Dim  bits[BytesTotal+1] As Byte = 0
        Dim  k0 As Word
        Dim RamByte[BytesTotal+1] As Byte = 0

        bits[GrupFila] = 1 - Zerobit ; // inserta un bit <<< 1 a la fila

        For k0 = 0 To BytesTotal-1 Step 1
            RamByte[k0] = Read_MultiByteArray display_ram, [(y2*GrupFila) + k0, y1]
        Next

        For k0 = 0 To BytesTotal - 1 Step 1
                If RamByte[k0] & $80  <> 0 Then
                                                bits[k0] = 1
                                           Else
                                                bits[k0] = 0
                End If
                RamByte[k0] = RamByte[k0] << 1
         Next

         For k0 = 0 To BytesTotal - 1 Step 1
            Write_MultiByteArray display_ram,[(y2*GrupFila) +k0 ,y1],(RamByte[k0] + bits[k0 + 1])
         Next
EndProc

[Pepe]

I think that's how it should work too.

Code Select Expand

Proc LineScroll( Lines As Byte, ZeroBit As Bit) ,Bit

    Dim y1 As Word = Lines // 4
    Dim y2 As Word = Lines / 4 
    Dim  bits[BytesTotal+1] As Byte = 0
    Dim  k0 As Word
    Dim RamByte[BytesTotal+1] As Byte = 0
         
         bits[GrupFila] = ~ ZeroBit
         
         For k0 = 0 To BytesTotal -1
            RamByte[k0] = Read_MultiByteArray display_ram, [(y2*GrupFila)+k0,y1]
         Next
         
         For k0 = 0 To BytesTotal-1
           
            If RamByte[k0] & $80  <> 0 Then
                                            bits[k0] = 1
                                       Else
                                            bits[k0] = 0
            End If                                 
                                           
            RamByte[k0] = RamByte[k0] << 1
           
         Next
         
         For k0 = 0 To BytesTotal-1
         
            Write_MultiByteArray display_ram,[(y2*GrupFila)+k0 ,y1],(RamByte[k0] | bits[k0+1])
           
         Next
EndProc