Display TFT ST7789 (OshonSoft Basic).

DogFlu66 said:

I have merged it with the initial libraries and it has become as follows:

Code:

'*************************************************************************
' Special Command Signifiers
'*************************************************************************
Const ST_CMD_DELAY    =  0x80    ' Special signifier for command lists
'*************************************************************************
' Basic ST7789 Commands
'*************************************************************************
Const ST77XX_NOP      =  0x00    ' No operation
Const ST77XX_SWRESET  =  0x01    ' Software reset
Const ST77XX_RDDID    =  0x04    ' Read display ID
Const ST77XX_RDDST    =  0x09    ' Read display status

Const ST77XX_SLPIN    =  0x10    ' Enter sleep mode
Const ST77XX_SLPOUT   =  0x11    ' Exit sleep mode
Const ST77XX_PTLON    =  0x12    ' Enable partial mode
Const ST77XX_NORON    =  0x13    ' Exit partial mode (normal display mode)

Const ST77XX_INVOFF   =  0x20    ' Display inversion off
Const ST77XX_INVON    =  0x21    ' Display inversion on
Const ST77XX_DISPOFF  =  0x28    ' Display off
Const ST77XX_DISPON   =  0x29    ' Display on
Const ST77XX_CASET    =  0x2A    ' Column address set
Const ST77XX_RASET    =  0x2B    ' Row address set
Const ST77XX_RAMWR    =  0x2C    ' Memory write
Const ST77XX_RAMRD    =  0x2E    ' Memory read

Const ST77XX_PTLAR    =  0x30    ' Partial area
Const ST77XX_COLMOD   =  0x3A    ' Interface pixel format
Const ST77XX_MADCTL   =  0x36    ' Memory access control
Const ST77xx_DISP_FUNC = 0xB6    ' Display function control

'*************************************************************************
' MADCTL Options (Memory Access Control Register)
'*************************************************************************
Const ST77XX_MADCTL_MY  = 0x80    ' Row address order (top to bottom)
Const ST77XX_MADCTL_MX  = 0x40    ' Column address order (left to right)
Const ST77XX_MADCTL_MV  = 0x20    ' Row/column exchange (rotation)
Const ST77XX_MADCTL_ML  = 0x10    ' Vertical refresh order
Const ST77XX_MADCTL_RGB = 0x08    ' RGB color order (default)

'*************************************************************************
' ID Reading Commands
'*************************************************************************
Const ST77XX_RDID1     = 0xDA    ' Read ID part 1
Const ST77XX_RDID2     = 0xDB    ' Read ID part 2
Const ST77XX_RDID3     = 0xDC    ' Read ID part 3
Const ST77XX_RDID4     = 0xDD    ' Read ID part 4

'*************************************************************************
' Predefined 16-Bit Colors (RGB565 Format)
'*************************************************************************
Const LCD_BLACK   = 0x0000    ' Black color
Const LCD_RED     = 0x001F    ' Red color
Const LCD_BLUE    = 0xF800    ' Blue color
Const LCD_GREEN   = 0x07E0    ' Green color
Const LCD_YELLOW  = 0x07FF    ' Yellow color (Red + Green)
Const LCD_MAGENTA = 0xF81F    ' Magenta color (Red + Blue)
Const LCD_CYAN    = 0xFFE0    ' Cyan color (Green + Blue)
Const LCD_WHITE   = 0xFFFF    ' White color (Red + Green + Blue)
''/**************************************************************************/
''    @brief  Configuration and control of SPI for ST7789 display
''            Includes SPI initialization and command writing procedures.
''**************************************************************************/

'*************************************************************************
' Constants and Pin Definitions
'*************************************************************************

' LCD dimensions (modified by current rotation settings)
Const LCD_width = 320        ' Display width
Const LCD_height = 240       ' Display height

' SPI Pin Definitions
Symbol TFT_RST = LATC.0      ' Reset pin (RST)
Symbol TFT_DC  = LATC.1      ' Data/Command pin (DC/SS)
Symbol TFT_CS  = LATC.2      ' Chip Select pin (CS)
Symbol TFT_SCK = LATC.3      ' Clock pin (SCK)
Symbol TFT_SDI = PORTC.4     ' Serial Data In (SDI, input)
Symbol TFT_SDO = LATC.5      ' Serial Data Out (SDO, output)

' SPI Pin I/O Definitions
Symbol TFT_RST_IO = PORTC.0  ' Reset pin as I/O
Symbol TFT_DC_IO  = PORTC.1  ' Data/Command pin as I/O
Symbol TFT_CS_IO  = PORTC.2  ' Chip Select pin as I/O
Symbol TFT_SCK_IO = PORTC.3  ' Clock pin as I/O
Symbol TFT_SDI_IO = PORTC.4  ' Serial Data In pin as I/O
Symbol TFT_SDO_IO = PORTC.5  ' Serial Data Out pin as I/O

' SPI Operation Modes
Const LCD_SPI_MODE0 = 0         ' Clock low, data sampled on rising edge
Const LCD_SPI_MODE1 = 1         ' Clock low, data sampled on falling edge
Const LCD_SPI_MODE2 = 2         ' Clock high, data sampled on falling edge
Const LCD_SPI_MODE3 = 3         ' Clock high, data sampled on rising edge

' SPI Speeds
Const LCD_SPI_MASTER_SPEED0 = 0 ' Clock Fosc/4
Const LCD_SPI_MASTER_SPEED1 = 1 ' Clock Fosc/16
Const LCD_SPI_MASTER_SPEED2 = 2 ' Clock Fosc/64
Const LCD_SPI_MASTER_SPEED3 = 3 ' Clock TMR2 output/2

' Data Sampling Points
Const LCD_SMP_MIDDLE = %00000000 ' Data sampled in the middle of the output time
Const LCD_SMP_END    = %10000000 ' Data sampled at the end of the output time

' SPI Module Enable/Disable
Const LCD_SPI_ENABLE  = %00100000 ' Enable SSP module
Const LCD_SPI_DISABLE = %00000000 ' Disable SSP module

'*************************************************************************
' SPI Initialization Procedure
'*************************************************************************

'' @brief  Initializes the SPI module (MSSP1) in master mode.
''         Configures SPI mode, speed, and pin directions.
'' @param  mode  SPI operation mode (0 to 3).
'' @param  speed SPI speed setting (bits 3-0 of SSPCON1).
Proc LCD_SPI1_Init(mode As Byte, speed As Byte)
    ' Configure SPI pins
    ConfigPin TFT_RST_IO = Output   ' RESET pin as output
    ConfigPin TFT_DC_IO = Output    ' Data/Command pin as output
    ConfigPin TFT_CS_IO = Output    ' Chip Select pin as output
    ConfigPin TFT_SCK_IO = Output   ' Clock pin as output
    ConfigPin TFT_SDI_IO = Input    ' SDI pin as input
    ConfigPin TFT_SDO_IO = Output   ' SDO pin as output

    ' Configure SPI operation mode
    Select Case mode
        Case 0
            SSP1CON1.4 = 0 ' CKP = 0 (clock idle low)
            SSP1STAT.6 = 1 ' CKE = 1 (data changes on falling edge, sampled on rising edge)
        Case 1
            SSP1CON1.4 = 0 ' CKP = 0 (clock idle low)
            SSP1STAT.6 = 0 ' CKE = 0 (data changes on rising edge, sampled on falling edge)
        Case 2
            SSP1CON1.4 = 1 ' CKP = 1 (clock idle high)
            SSP1STAT.6 = 1 ' CKE = 1 (data changes on rising edge, sampled on falling edge)
        Case 3
            SSP1CON1.4 = 1 ' CKP = 1 (clock idle high)
            SSP1STAT.6 = 0 ' CKE = 0 (data changes on falling edge, sampled on rising edge)
    EndSelect

    ' Configure SPI speed and enable the module
    SSP1CON1 = SSP1CON1 | speed
End Proc

'*************************************************************************
' LCD Command Writing Procedure
'*************************************************************************

'' @brief  Sends a command byte to the LCD.
''         Controls DC and CS pins for proper communication.
'' @param  dat  Command byte to be sent.
Proc LCD_WRITE_COM(dat As Byte)
    TFT_CS = 0            ' Enable the LCD (Chip Select active)
    TFT_DC = 0            ' Set to command mode (DC low)
    SSPBUF = dat          ' Load the command byte into the SPI buffer
    While SSPSTAT.BF = 0  ' Wait for the transmission to complete
    Wend
    TFT_DC = 1            ' Return to data mode (DC high)
    TFT_CS = 1            ' Disable the LCD (Chip Select inactive)
End Proc
'' @brief  Sends a data byte to the LCD over SPI.
''         Controls the Data/Command (DC) and Chip Select (CS) pins to
''         indicate that the transmitted byte is data.
'' @param  dat  The data byte to send to the LCD.
Proc LCD_WRITE_DATA(dat As Byte)
    ' Select the LCD (Chip Select active)
    TFT_CS = 0

    ' Set DC pin high to indicate data mode
    TFT_DC = 1

    ' Send the data byte via SPI
    SSPBUF = dat

    ' Wait for the SPI transmission to complete
    While SSPSTAT.BF = 0
    Wend

    ' Optionally keep DC high, as it is data mode by default
    TFT_DC = 1

    ' Deselect the LCD (Chip Select inactive)
    TFT_CS = 1
End Proc
''/**************************************************************************/
''    @brief  Initialization code for ST7789 display
''            This function initializes the display controller using a
''            predefined sequence of commands and data. It sets up power,
''            timing, and display configuration parameters.
''/**************************************************************************/
Proc LCD_init()

    ' Reset sequence for the display controller
    High TFT_RST                ' Set the reset pin high
    ' ConfigPin TFT_RST = Output ' Ensure the pin is configured as output
    WaitMs 100                  ' Wait 100ms
    Low TFT_RST                 ' Pull the reset pin low
    WaitMs 100                  ' Wait 100ms
    High TFT_RST                ' Set the reset pin high again
    WaitMs 200                  ' Wait 200ms for the reset to complete

    ' Send software reset command
    Call LCD_WRITE_COM(ST77XX_SWRESET)  ' Software reset
    WaitMs 150                          ' Wait for the reset to take effect

    ' Turn off the display (preparation step)
    Call LCD_WRITE_COM(ST77XX_DISPOFF)  ' Display off

    ' Power control A configuration
    Call LCD_WRITE_COM(0xCB)
    Call LCD_WRITE_DATA(0x39)
    Call LCD_WRITE_DATA(0x2C)
    Call LCD_WRITE_DATA(0x00)
    Call LCD_WRITE_DATA(0x34)
    Call LCD_WRITE_DATA(0x02)
    WaitMs 1

    ' Power control B configuration
    Call LCD_WRITE_COM(0xCF)
    Call LCD_WRITE_DATA(0x00)
    Call LCD_WRITE_DATA(0xC1)
    Call LCD_WRITE_DATA(0x30)
    WaitMs 1

    ' Timing control A configuration
    Call LCD_WRITE_COM(0xE8)
    Call LCD_WRITE_DATA(0x85)
    Call LCD_WRITE_DATA(0x10)
    Call LCD_WRITE_DATA(0x78)
    WaitMs 1

    ' Timing control B configuration
    Call LCD_WRITE_COM(0xEA)
    Call LCD_WRITE_DATA(0x00)
    Call LCD_WRITE_DATA(0x00)
    WaitMs 1

    ' Power-on sequence control
    Call LCD_WRITE_COM(0xED)
    Call LCD_WRITE_DATA(0x64)
    Call LCD_WRITE_DATA(0x03)
    Call LCD_WRITE_DATA(0x12)
    Call LCD_WRITE_DATA(0x81)

    ' Power control 1 (VRH)
    Call LCD_WRITE_COM(0xC0)
    Call LCD_WRITE_DATA(0x26)

    ' Power control 2 (SAP and BT settings)
    Call LCD_WRITE_COM(0xC1)
    Call LCD_WRITE_DATA(0x11)

    ' VCM control (Contrast settings)
    Call LCD_WRITE_COM(0xC5)
    Call LCD_WRITE_DATA(0x3E)
    Call LCD_WRITE_DATA(0x28)

    ' Frame rate control (set to default)
    Call LCD_WRITE_COM(0xF7)
    Call LCD_WRITE_DATA(0x20)

    ' Memory access control (MADCTL)
    Call LCD_WRITE_COM(ST77XX_MADCTL)
    Call LCD_WRITE_DATA(0x08)   ' Set orientation and RGB order

    ' Disable display inversion
    Call LCD_WRITE_COM(ST77XX_INVOFF)

    ' Normal display mode
    Call LCD_WRITE_COM(ST77XX_NORON)
    WaitMs 1

    ' Set pixel format to 16 bits per pixel
    Call LCD_WRITE_COM(ST77XX_COLMOD)
    Call LCD_WRITE_DATA(0x55)

    ' Entry mode configuration
    Call LCD_WRITE_COM(0xB7)
    Call LCD_WRITE_DATA(0x07)

    ' Display function control
    Call LCD_WRITE_COM(ST77xx_DISP_FUNC)
    Call LCD_WRITE_DATA(0x08)
    Call LCD_WRITE_DATA(0x82)
    Call LCD_WRITE_DATA(0x27)
    WaitMs 1

    ' Exit sleep mode
    Call LCD_WRITE_COM(ST77XX_SLPOUT)
    WaitMs 120                  ' Wait for the display to wake up

    ' Turn on the display
    Call LCD_WRITE_COM(ST77XX_DISPON)
    WaitMs 1                    ' Wait for the display to turn on

End Proc
'/**************************************************************************/
'  @brief  SPI displays set an address window rectangle For blitting pixels
'  @param  x1  Top left corner x coordinate
'  @param  y1 Top left corner x coordinate
'  @param  x2  Width of window
'  @param  y2  Height of window
'/**************************************************************************/
Proc setAddrWindow(x1 As Word, y1 As Word, x2 As Word, y2 As Word)

    Call LCD_WRITE_COM(ST77XX_CASET)  //Column addr set
    Call LCD_WRITE_DATA(x1.HB)
    Call LCD_WRITE_DATA(x1.LB)
    Call LCD_WRITE_DATA(x2.HB)
    Call LCD_WRITE_DATA(x2.LB)
    Call LCD_WRITE_COM(ST77XX_RASET)  //Row addr set
    Call LCD_WRITE_DATA(y1.HB)
    Call LCD_WRITE_DATA(y1.LB)
    Call LCD_WRITE_DATA(y2.HB)
    Call LCD_WRITE_DATA(y2.LB)

    Call LCD_WRITE_COM(ST77XX_RAMWR)  //write to RAM
End Proc

'/**************************************************************************/
'    @brief  Set origin of (0,0) And orientation of TFT display
'    @param  m  The index For rotation, from 0-3 inclusive
'/**************************************************************************/
Proc SetRotation(m As Word)
  Dim rotation As Byte
  Dim madctl As Byte
  madctl = 0

  If m > 3 Then m = 3
   rotation = m

  Select Case (rotation)
   Case 0
     madctl  = ST77XX_MADCTL_MX | ST77XX_MADCTL_MY | ST77XX_MADCTL_RGB
   Case 1
     madctl  = ST77XX_MADCTL_MY | ST77XX_MADCTL_MV | ST77XX_MADCTL_RGB
  Case 2
     madctl  = ST77XX_MADCTL_RGB
   Case 3
     madctl  = ST77XX_MADCTL_MX | ST77XX_MADCTL_MV | ST77XX_MADCTL_RGB
  EndSelect
   Call LCD_WRITE_COM(ST77XX_MADCTL)
   Call LCD_WRITE_DATA(madctl)
End Proc
'    @brief  Draw a single pixel on the LCD at the specified coordinates.
'            The pixel color is defined in '565' RGB format.
'    @param  x1     X coordinate of the pixel.
'    @param  y1     Y coordinate of the pixel.
'    @param  color  16-bit pixel color in '565' RGB format.
Proc LCD_DrawPoint(x1 As Word, y1 As Word, color As Word)

    ' Set column address (X coordinate)
    Call LCD_WRITE_COM(ST77XX_CASET)  // Column address set
    Call LCD_WRITE_DATA(x1.HB)        // High byte of X coordinate
    Call LCD_WRITE_DATA(x1.LB)        // Low byte of X coordinate

    ' Set row address (Y coordinate)
    Call LCD_WRITE_COM(ST77XX_RASET)  // Row address set
    Call LCD_WRITE_DATA(y1.HB)        // High byte of Y coordinate
    Call LCD_WRITE_DATA(y1.LB)        // Low byte of Y coordinate

    ' Write pixel data to RAM
    Call LCD_WRITE_COM(ST77XX_RAMWR)  // Write to RAM
    Call LCD_WRITE_DATA(color.HB)     // High byte of color
    Call LCD_WRITE_DATA(color.LB)     // Low byte of color

End Proc
Proc DrawPixel(x As Word, y As Word, color As Word)

    Call LCD_WRITE_COM(ST77XX_CASET)  //Column addr set
    Call LCD_WRITE_DATA(x.HB)
    Call LCD_WRITE_DATA(x.LB)
    Call LCD_WRITE_COM(ST77XX_RASET)  //Row addr set
    Call LCD_WRITE_DATA(y.HB)
    Call LCD_WRITE_DATA(y.LB)
    Call LCD_WRITE_COM(ST77XX_RAMWR)  //write to RAM

    Call LCD_WRITE_DATA(color.HB)
    Call LCD_WRITE_DATA(color.LB)

End Proc
'    @brief  Draw a straight line on the LCD using Bresenham's line algorithm.
'            The line is defined by its start and end points and is drawn pixel by pixel.
'    @param  x1     X coordinate of the starting point.
'    @param  y1     Y coordinate of the starting point.
'    @param  x2     X coordinate of the ending point.
'    @param  y2     Y coordinate of the ending point.
'    @param  color  16-bit pixel color in '565' RGB format.
Proc LCD_DrawLine(x1 As Word, y1 As Word, x2 As Word, y2 As Word, color As Word)

    Dim t As Word
    Dim xerr, yerr, delta_x, delta_y, distance As Integer
    Dim incx, incy, xPix, yPix As Integer
    xerr = 0
    yerr = 0

    delta_x = x2 - x1
    delta_y = y2 - y1
    xPix = x1
    yPix = y1

    ' Determine the direction of the line
    If delta_x > 0 Then incx = 1
    If delta_x = 0 Then incx = 0
    If delta_x < 0 Then
        incx = -1
        delta_x = -delta_x
    Endif

    If delta_y > 0 Then incy = 1
    If delta_y = 0 Then incy = 0
    If delta_y < 0 Then
        incy = -1
        delta_y = -delta_y
    Endif

    ' Determine the distance to iterate
    If delta_x > delta_y Then
        distance = delta_x
    Else
        distance = delta_y
    Endif

    ' Draw the line pixel by pixel
    For t = 0 To distance + 1 Step 1
        Call LCD_DrawPoint(xPix, yPix, color) ' Draw current pixel
        xerr = xerr + delta_x
        yerr = yerr + delta_y
        If xerr > distance Then
            xerr = xerr - distance
            xPix = xPix + incx
        Endif
        If yerr > distance Then
            yerr = yerr - distance
            yPix = yPix + incy
        Endif
    Next t

End Proc
'/**************************************************************************/
'   @brief    Draw A perfectly horizontal line (this is often optimized in A subclass!)
'    @param    x   Left-most x coordinate
'    @param    y   Left-most y coordinate
'    @param    W   Width in pixels
'   @param    color 16-Bit 5-6-5 Color To fill with
'/**************************************************************************/
Proc drawHLine(x As Byte, y As Byte, _W As Byte, color As Word)

    Call LCD_DrawLine(x, y, _W, 1, color)

End Proc

'/**************************************************************************/
'   @brief    Draw A perfectly vertical line (this is often optimized in A subclass!)
'    @param    x   Top-most x coordinate
'    @param    y   Top-most y coordinate
'    @param    h   Height in pixels
'   @param    color 16-Bit 5-6-5 Color To fill with
'/**************************************************************************/
Proc drawVLine(x As Word, y As Word, h As Word, color As Word)

    Call LCD_DrawLine(x, y, 1, h, color)

End Proc
'    @brief  Draw a rectangle on the LCD by connecting four lines.
'            The rectangle is defined by its top-left and bottom-right corners.
'    @param  x1     X coordinate of the top-left corner.
'    @param  y1     Y coordinate of the top-left corner.
'    @param  x2     X coordinate of the bottom-right corner.
'    @param  y2     Y coordinate of the bottom-right corner.
'    @param  color  16-bit pixel color in '565' RGB format.
Proc LCD_DrawRectangle(x1 As Integer, y1 As Integer, x2 As Integer, y2 As Integer, color As Word)

    ' Draw the top edge of the rectangle
    Call LCD_DrawLine(x1, y1, x2, y1, color)

    ' Draw the left edge of the rectangle
    Call LCD_DrawLine(x1, y1, x1, y2, color)

    ' Draw the bottom edge of the rectangle
    Call LCD_DrawLine(x1, y2, x2, y2, color)

    ' Draw the right edge of the rectangle
    Call LCD_DrawLine(x2, y1, x2, y2, color)

End Proc
'/**************************************************************************/
'   @brief    Fill A rectangle completely with one color. Update in subclasses If desired!
'    @param    x   Top left corner x coordinate
'    @param    y   Top left corner y coordinate
'    @param    W   Width in pixels
'    @param    h   Height in pixels
'   @param    color 16-Bit 5-6-5 Color To fill with
'/**************************************************************************/
Proc fillRect(x1 As Word, y1 As Word, x2 As Word, y2 As Word, color As Word)

    Dim px As Long
    If x2 > 0 And y2 > 0 Then      //Nonzero width and height?
        Call setAddrWindow(x1, y1, x2, y2)
        px = x2
        px = px * y2
        TFT_CS = 0
        TFT_DC = 1
        While px > 1
            SSP1BUF = color.HB
            While SSP1STAT.BF = 0
            Wend
            SSP1BUF = color.LB
            While SSP1STAT.BF = 0
            Wend
            --px
        Wend
        TFT_DC = 1
        TFT_CS = 1
    Endif

End Proc
'    @brief  Draw a circle on the LCD using the midpoint circle algorithm.
'            The circle is defined by its center coordinates, radius, and color.
'    @param  x1     Horizontal position of the circle's center (X coordinate).
'    @param  y1     Vertical position of the circle's center (Y coordinate).
'    @param  rad    Radius of the circle in pixels.
'    @param  color  16-bit pixel color in '565' RGB format.
Proc LCD_Circle(x1 As Word, y1 As Word, rad As Word, color As Word)

    Dim xPix, yPix, di As Integer
    xPix = 0
    yPix = rad
    di = 3 - rad << 1 'ShiftLeft(rad, 1)

    While xPix <= yPix

        ' Draw symmetric points for the circle
        Call LCD_DrawPoint(x1+xPix, y1-yPix, color)
        Call LCD_DrawPoint(x1+yPix, y1-xPix, color)
        Call LCD_DrawPoint(x1+yPix, y1+xPix, color)
        Call LCD_DrawPoint(x1+xPix, y1+yPix, color)
        Call LCD_DrawPoint(x1-xPix, y1+yPix, color)
        Call LCD_DrawPoint(x1-yPix, y1+xPix, color)
        Call LCD_DrawPoint(x1-xPix, y1-yPix, color)
        Call LCD_DrawPoint(x1-yPix, y1-xPix, color)

        xPix = xPix + 1

        ' Update decision parameter and adjust yPix if necessary
        If di < 0 Then
            di = di + (4 * xPix + 6)
        Else
            di = di + (10 + 4 * (xPix - yPix))
            yPix = yPix - 1
        Endif
    Wend

End Proc
'/**************************************************************************/
'   @brief    Fill the screen completely with one color. Update in subclasses If desired!
'    @param    color 16-Bit 5-6-5 Color To fill with
'/**************************************************************************/
Proc fillScreen(color As Word)
    Call fillRect(0, 0, LCD_width, LCD_height, color)
End Proc
Proc fillwindow(x1 As Word,y1 As Word,x2 As Word,y2 As Word,color As Word)
Call fillRect(x1, y1, x2, y2, color)
End Proc
'/**************************************************************************/
'    @brief  Invert the colors of the display (If supported by hardware).
'            Self-contained, no transaction setup required.
'    @param  i  True = inverted display, False = normal display.
'/**************************************************************************/
Proc invertDisplay(i As Bit)
    If i Then
        Call LCD_WRITE_COM(ST77XX_INVON)
    Else
        Call LCD_WRITE_COM(ST77XX_INVOFF)
    Endif
End Proc
'    @brief  Push a 16-bit color to the LCD RAM with a command transaction.
'            Deprecated function, preserved for backward compatibility.
'    @param  color  16-bit pixel color in '565' RGB format.
Proc pushColor(color As Word)

    Call LCD_WRITE_COM(ST77XX_RAMWR)  //write to RAM
    Call LCD_WRITE_DATA(color.HB)
    Call LCD_WRITE_DATA(color.LB)

End Proc

'    @brief  Draw a character at a specified position on the LCD.
'            Characters are rendered with foreground and background colors.
'    @param  char   ASCII character to display.
'    @param  x      Horizontal position (starting X coordinate).
'    @param  y      Vertical position (starting Y coordinate).
'    @param  fcol   Foreground color in '565' RGB format.
'    @param  bcol   Background color in '565' RGB format.
Proc LCD_Char(char As Byte, x As Word, y As Word, fcol As Word, bcol As Word)

    Dim  x0 As Integer
    Dim idx, idx2 As Byte
    Dim mask As Byte

    For idx = 0 To 9 Step 1
        mask = _LCDFnt(char, idx)
        For idx2 = 0 To 13 Step 2
            If mask And 0x80 Then
                Call LCD_DrawPoint(x+idx2, y, fcol)
                Call LCD_DrawPoint(x+idx2+1, y, fcol)
                Call LCD_DrawPoint(x+idx2, y+1, fcol)
                Call LCD_DrawPoint(x+idx2+1, y+1, fcol)
            Else
                Call LCD_DrawPoint(x+idx2, y, bcol)
                Call LCD_DrawPoint(x+idx2+1, y, bcol)
                Call LCD_DrawPoint(x+idx2, y+1, bcol)
                Call LCD_DrawPoint(x+idx2+1, y+1, bcol)
            Endif
            mask = ShiftLeft(mask,1)
        Next idx2
        y = y + 2
    Next idx

End Proc

'    @brief  Display a string of characters on the LCD at a given position.
'            Each character is rendered with specified foreground and background colors.
'    @param  str    String to display.
'    @param  x      Horizontal position (starting X coordinate).
'    @param  y      Vertical position (starting Y coordinate).
'    @param  fcol   Foreground color in '565' RGB format.
'    @param  bcol   Background color in '565' RGB format.
Proc LCD_String(str As String, x As Word, y As Word, fcol As Word, bcol As Word)

    Dim idx As Byte
    Dim x0 As Word
    idx = 0

    While str(idx) <> 0
        Call LCD_Char(str(idx), x, y, fcol, bcol)
        x = x + 18
        idx = idx + 1
    Wend

End Proc

Function _LCDFnt(ch As Byte, idx As Byte) As Byte
    Symbol Retval = _LCDFnt

            Select Case ch
                Case " "
                    Retval = LookUp(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00), idx  //SPACE
                Case "!"
                    Retval = LookUp(0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x08, 0x00), idx  //!
                Case 34
                    Retval = LookUp(0x00, 0x14, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00), idx  // "
                Case "#"
                    Retval = LookUp(0x00, 0x12, 0x12, 0x7f, 0x24, 0x24, 0xfe, 0x48, 0x48, 0x00), idx  //#
                Case "$"
                    Retval = LookUp(0x00, 0x10, 0x7c, 0x92, 0x70, 0x1c, 0x92, 0x7c, 0x10, 0x00), idx  //$
                Case "%"
                    Retval = LookUp(0x00, 0x41, 0xa2, 0x44, 0x08, 0x10, 0x22, 0x45, 0x82, 0x00), idx  //%
                Case "&"
                    Retval = LookUp(0x00, 0x10, 0x28, 0x10, 0x28, 0x44, 0x43, 0x42, 0x39, 0x00), idx  //&
                Case "'"
                    Retval = LookUp(0x00, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00), idx  //'
                Case "("
                    Retval = LookUp(0x00, 0x08, 0x10, 0x20, 0x20, 0x20, 0x20, 0x10, 0x08, 0x00), idx  //(
                Case ")"
                    Retval = LookUp(0x00, 0x08, 0x04, 0x02, 0x02, 0x02, 0x20, 0x04, 0x08, 0x00), idx  //)
                Case "*"
                    Retval = LookUp(0x00, 0x08, 0x2a, 0x1c, 0x7f, 0x1c, 0x2a, 0x08, 0x00, 0x00), idx  //*
                Case "+"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x08, 0x08, 0x00, 0x00), idx  //+
                Case ","
                    Retval = LookUp(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x10, 0x00), idx  //,
                Case "-"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00), idx  //-
                Case "."
                    Retval = LookUp(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x00), idx  //.
                Case "/"
                    Retval = LookUp(0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00), idx  ///
                Case "0"
                    Retval = LookUp(0x00, 0x3c, 0x46, 0x4a, 0x4a, 0x52, 0x52, 0x62, 0x3c, 0x00), idx  //0
                Case "1"
                    Retval = LookUp(0x00, 0x08, 0x18, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3e, 0x00), idx  //1
                Case "2"
                    Retval = LookUp(0x00, 0x3c, 0x42, 0x02, 0x0c, 0x30, 0x40, 0x40, 0x7e, 0x00), idx  //2
                Case "3"
                    Retval = LookUp(0x00, 0x3c, 0x42, 0x02, 0x0c, 0x02, 0x02, 0x42, 0x3c, 0x00), idx  //3
                Case "4"
                    Retval = LookUp(0x00, 0x09, 0x18, 0x28, 0x48, 0x48, 0x7e, 0x08, 0x08, 0x00), idx  //4
                Case "5"
                    Retval = LookUp(0x00, 0x7e, 0x40, 0x40, 0x7c, 0x02, 0x02, 0x42, 0x3c, 0x00), idx  //5
                Case "6"
                    Retval = LookUp(0x00, 0x3c, 0x42, 0x40, 0x7c, 0x42, 0x42, 0x42, 0x3c, 0x00), idx  //6
                Case "7"
                    Retval = LookUp(0x00, 0x7e, 0x02, 0x02, 0x04, 0x08, 0x10, 0x10, 0x10, 0x00), idx  //7
                Case "8"
                    Retval = LookUp(0x00, 0x3c, 0x42, 0x42, 0x3c, 0x42, 0x42, 0x42, 0x3c, 0x00), idx  //8
                Case "9"
                    Retval = LookUp(0x00, 0x3c, 0x42, 0x42, 0x3e, 0x02, 0x02, 0x42, 0x3c, 0x00), idx  //9
                Case ":"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x08, 0x08, 0x00, 0x08, 0x08, 0x00, 0x00), idx  //:
                Case ";"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x08, 0x08, 0x00, 0x08, 0x08, 0x10, 0x00), idx  //;
                Case "<"
                    Retval = LookUp(0x00, 0x04, 0x08, 0x10, 0x20, 0x20, 0x10, 0x08, 0x04, 0x00), idx  //<
                Case "="
                    Retval = LookUp(0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x3e, 0x00, 0x00, 0x00), idx  //=
                Case ">"
                    Retval = LookUp(0x00, 0x10, 0x08, 0x04, 0x02, 0x02, 0x04, 0x08, 0x10, 0x00), idx  //>
                Case "?"
                    Retval = LookUp(0x00, 0x3c, 0x42, 0x02, 0x04, 0x08, 0x08, 0x00, 0x08, 0x00), idx  //?
                Case "@"
                    Retval = LookUp(0x00, 0x7e, 0x81, 0x9b, 0xa5, 0xa6, 0x9c, 0x81, 0x7e, 0x00), idx  //@
                Case "A"
                    Retval = LookUp(0x00, 0x18, 0x24, 0x42, 0x42, 0x7e, 0x42, 0x42, 0x42, 0x00), idx  //A
                Case "B"
                    Retval = LookUp(0x00, 0x7c, 0x42, 0x42, 0x7c, 0x42, 0x42, 0x42, 0x7c, 0x00), idx  //B
                Case "C"
                    Retval = LookUp(0x00, 0x3c, 0x42, 0x40, 0x40, 0x40, 0x40, 0x42, 0x3c, 0x00), idx  //C
                Case "D"
                    Retval = LookUp(0x00, 0x7c, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7c, 0x00), idx  //D
                Case "E"
                    Retval = LookUp(0x00, 0x7e, 0x40, 0x40, 0x78, 0x40, 0x40, 0x40, 0x7e, 0x00), idx  //E
                Case "F"
                    Retval = LookUp(0x00, 0x7e, 0x40, 0x40, 0x78, 0x40, 0x40, 0x40, 0x40, 0x00), idx  //F
                Case "G"
                    Retval = LookUp(0x00, 0x3c, 0x42, 0x40, 0x40, 0x46, 0x42, 0x42, 0x3c, 0x00), idx  //G
                Case "H"
                    Retval = LookUp(0x00, 0x42, 0x42, 0x42, 0x7e, 0x42, 0x42, 0x42, 0x42, 0x00), idx  //H
                Case "I"
                    Retval = LookUp(0x00, 0x7e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x7e, 0x00), idx  //I
                Case "J"
                    Retval = LookUp(0x00, 0x7e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x48, 0x30, 0x00), idx  //J
                Case "K"
                    Retval = LookUp(0x00, 0x42, 0x44, 0x48, 0x70, 0x48, 0x44, 0x42, 0x42, 0x00), idx  //K
                Case "L"
                    Retval = LookUp(0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7e, 0x00), idx  //L
                Case "M"
                    Retval = LookUp(0x00, 0x42, 0x42, 0x66, 0x5a, 0x42, 0x42, 0x42, 0x42, 0x00), idx  //M
                Case "N"
                    Retval = LookUp(0x00, 0x42, 0x42, 0x62, 0x52, 0x4a, 0x46, 0x42, 0x42, 0x00), idx  //N
                Case "O"
                    Retval = LookUp(0x00, 0x3c, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3c, 0x00), idx  //O
                Case "P"
                    Retval = LookUp(0x00, 0x7c, 0x42, 0x42, 0x7c, 0x40, 0x40, 0x40, 0x40, 0x00), idx  //P
                Case "Q"
                    Retval = LookUp(0x00, 0x3c, 0x42, 0x42, 0x42, 0x42, 0x4a, 0x46, 0x3e, 0x00), idx  //Q
                Case "R"
                    Retval = LookUp(0x00, 0x7c, 0x42, 0x42, 0x7c, 0x48, 0x44, 0x42, 0x42, 0x00), idx  //R
                Case "S"
                    Retval = LookUp(0x00, 0x3c, 0x42, 0x40, 0x30, 0x0c, 0x02, 0x42, 0x3c, 0x00), idx  //S
                Case "T"
                    Retval = LookUp(0x00, 0x7e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00), idx  //T
                Case "U"
                    Retval = LookUp(0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3c, 0x00), idx  //U
                Case "V"
                    Retval = LookUp(0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x24, 0x18, 0x00), idx  //V
                Case "W"
                    Retval = LookUp(0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x5a, 0x66, 0x42, 0x00), idx  //W
                Case "X"
                    Retval = LookUp(0x00, 0x42, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x42, 0x00), idx  //X
                Case "Y"
                    Retval = LookUp(0x00, 0x42, 0x42, 0x24, 0x18, 0x05, 0x08, 0x08, 0x08, 0x00), idx  //Y
                Case "Z"
                    Retval = LookUp(0x00, 0x7e, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x7e, 0x00), idx  //Z
                Case "["
                    Retval = LookUp(0x00, 0x3c, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x00), idx  //[
                Case "\"
                    Retval = LookUp(0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00), idx  //\
                Case "]"
                    Retval = LookUp(0x00, 0x3c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x3c, 0x00), idx  //]
                Case "^"
                    Retval = LookUp(0x00, 0x08, 0x14, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00), idx  //^
                Case "_"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00), idx  //_
                Case "`"
                    Retval = LookUp(0x00, 0x10, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00), idx  //`
                Case "a"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x1c, 0x02, 0x1e, 0x22, 0x22, 0x1e, 0x00), idx  //a
                Case "b"
                    Retval = LookUp(0x00, 0x20, 0x20, 0x3c, 0x22, 0x22, 0x22, 0x22, 0x3c, 0x00), idx  //b
                Case "c"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x1c, 0x22, 0x20, 0x20, 0x22, 0x1c, 0x00), idx  //c
                Case "d"
                    Retval = LookUp(0x00, 0x02, 0x02, 0x1e, 0x22, 0x22, 0x22, 0x22, 0x1e, 0x00), idx  //d
                Case "e"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x1c, 0x22, 0x3e, 0x20, 0x22, 0x1c, 0x00), idx  //e
                Case "f"
                    Retval = LookUp(0x00, 0x0c, 0x10, 0x10, 0x3c, 0x10, 0x10, 0x10, 0x10, 0x00), idx  //f
                Case "g"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x1e, 0x22, 0x22, 0x22, 0x1e, 0x02, 0x3c), idx  //g
                Case "h"
                    Retval = LookUp(0x00, 0x20, 0x20, 0x3c, 0x22, 0x22, 0x22, 0x22, 0x22, 0x00), idx  //h
                Case "i"
                    Retval = LookUp(0x00, 0x08, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00), idx  //i
                Case "j"
                    Retval = LookUp(0x00, 0x08, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x30), idx  //j
                Case "k"
                    Retval = LookUp(0x00, 0x20, 0x20, 0x22, 0x24, 0x38, 0x24, 0x22, 0x22, 0x00), idx  //k
                Case "l"
                    Retval = LookUp(0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x18, 0x00), idx  //l
                Case "m"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x22, 0x36, 0x2a, 0x22, 0x22, 0x22, 0x00), idx  //m
                Case "n"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x3c, 0x22, 0x22, 0x22, 0x22, 0x22, 0x00), idx  //n
                Case "o"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x1c, 0x22, 0x22, 0x22, 0x22, 0x1c, 0x00), idx  //o
                Case "p"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x7c, 0x14, 0x14, 0x14, 0x08, 0x00, 0x00), idx  //p
                Case "q"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x3c, 0x22, 0x22, 0x22, 0x3c, 0x20, 0x20), idx  //q
                Case "r"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x2e, 0x30, 0x20, 0x20, 0x20, 0x20, 0x00), idx  //r
                Case "s"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x1c, 0x22, 0x10, 0x0c, 0x22, 0x1c, 0x00), idx  //s
                Case "t"
                    Retval = LookUp(0x00, 0x10, 0x10, 0x38, 0x10, 0x10, 0x10, 0x12, 0x0c, 0x00), idx  //t
                Case "u"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1c, 0x00), idx  //u
                Case "v"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x22, 0x14, 0x08, 0x00), idx  //v
                Case "w"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x2a, 0x36, 0x22, 0x00), idx  //w
                Case "x"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x22, 0x14, 0x08, 0x14, 0x22, 0x22, 0x00), idx  //x
                Case "y"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x22, 0x1e, 0x02, 0x3c), idx  //y
                Case "z"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x3e, 0x02, 0x04, 0x08, 0x10, 0x3e, 0x00), idx  //z
                Case "{"
                    Retval = LookUp(0x00, 0x04, 0x08, 0x08, 0x08, 0x10, 0x08, 0x08, 0x08, 0x04), idx  //{
                Case "|"
                    Retval = LookUp(0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00), idx  //|
                Case "}"
                    Retval = LookUp(0x00, 0x10, 0x08, 0x08, 0x08, 0x04, 0x08, 0x08, 0x08, 0x10), idx  //}
                Case "~"
                    Retval = LookUp(0x00, 0x00, 0x00, 0x00, 0xcc, 0x33, 0x00, 0x00, 0x00, 0x00), idx  //~
                Case 165 '"Ñ" + chr(165) +
                    Retval = LookUp(0x00, 0x00, 0x00, 0x7e, 0x05, 0x09, 0x11, 0x7e), idx  //Ñ
                Case 164'"ñ" + chr(164) +
                    Retval = LookUp(0x00, 0x00, 0x00, 0x78, 0x12, 0x0a, 0x0a, 0x70), idx  //ñ
            EndSelect

End Function

Click to expand...

Hi D and I,
Thanks.
With both of your CODEs I have to alter them to make them work.
e,g, there is no SSP1CON1 with the 18F46K20, and they don't oscillate, so I use my XTL oscillator.
Ian's is almost working, but I can't change some of the settings, e,g, sreen writing direction.

Using my set up with DOG's CODE, it compiles, but the [ Proc LCD_init() ] section stops my LED and SCREEN indicator working, maybe the oscillator?.

I don't expect either of you to mess about with my CODE, so you can devolop the TFT without needing to get held up by me. I'm afraid this is due to the limit of my programming skills. {tiresome!}

Do either of you mind me posting your CODE on the AAC forum?
C

Hi C.

That may be a typo on Dogs code as I use SSPCON1 and always have.

Post me your current code. I'll see what gives..

Which code do you want on AAC?

I use the Pic18F46K22 which has two MSSP modules, and I have the habit of configuring the registers with the names of the datasheet. In my case it would be SSP1CON1, to make it compatible you just have to delete the "1" in the middle of the registers, this register would be SSPCON1 for your Pic. However, the 18F46K22 for the MSSP1 accepts both, so I will edit it and change it because it works for me in both ways.

I think that to publish the libraries in another forum we would first have to finish the final ones, but for my part there is no problem.

DogFlu66 said:

I use the Pic18F46K22 which has two MSSP modules, and I have the habit of configuring the registers with the names of the datasheet. In my case it would be SSP1CON1, to make it compatible you just have to delete the "1" in the middle of the registers, this register would be SSPCON1 for your Pic. However, the 18F46K22 for the MSSP1 accepts both, so I will edit it and change it because it works for me in both ways.

I think that to publish the libraries in another forum we would first have to finish the final ones, but for my part there is no problem.

Click to expand...

Hi D,
I went through your CODE and changed the SSP1CON1 toSSPCON1. They look the same in both D/S.
As mentioned your CODE stops due to the LCD_INIT.
Well done with the commenting, it helps a lot.
C.

Ian Rogers said:

Hi C.

Post me your current code. I'll see what gives..

Which code do you want on AAC?

Click to expand...

Hi I and D,
I'll post the CODE later, but it is set up to use my PCB which has a crystal controlling the osc.
Earlier I offered that I post you one of my PCBs (Also you D) no problem if you prefer your electronics.

I hoped to use your CODE body, within my set up, which is working and I can change some of the settings, but not MADCTL.
C.

I'm leaving work now, if nothing unexpected happens I'll send you the modified TFT library and test program.

Hi C,

If the program stops at LCD init, then the I2C is struggling...

Run the I2C at 4Mhz until you get the thing sorted Mine is at 8Mhz so just increase the speed by 1

ie instead of SSPCON1 = 0x30 use SSPCON1 = 0x31

Also... Where are you at C.. I'm in Oldham just send me your board and I'll check it out!