ST7920.c

//-------------------------------------------------------------------------------------------------

//

//-------------------------------------------------------------------------------------------------

#include <avr/io.h>

//#define INTERFACE_8_BIT

// save program memory -> we do not use _delay_us()

// 1 nop per MHz (adapt if needed)

#define DELAY_1US \

    {           \

    __asm__ __volatile__("nop"); \

    __asm__ __volatile__("nop"); \

    __asm__ __volatile__("nop"); \

    __asm__ __volatile__("nop"); \

    __asm__ __volatile__("nop"); \

    __asm__ __volatile__("nop"); \

    __asm__ __volatile__("nop"); \

    __asm__ __volatile__("nop"); \

    __asm__ __volatile__("nop"); \

    __asm__ __volatile__("nop"); \

    __asm__ __volatile__("nop"); \

    __asm__ __volatile__("nop"); \

    }

#define CMD_DISPLAY_CLEAR   0x01

#define CMD_RETURN_HOME     0x02

#define CMD_ENTRY_MODE      0x04

#define CMD_DISPLAY_CONTROL 0x08

#define CMD_CURSOR_CONTROL  0x10

#define CMD_FUNCTION_SET    0x20

#define CMD_SET_CGRAM_ADR   0x40

#define CMD_SET_DDRAM_ADR   0x80

#define CMDE_STANDBY        0x01

#define CMDE_SCROLL_SEL     0x02

#define CMDE_REVERSE_LINE   0x04

#define CMDE_SET_SCROLL_ADR 0x40

#define CMDE_SET_GDRAM_ADR  0x80

#define BIT_ID              0x02

#define BIT_S               0x01

#define BIT_D               0x04

#define BIT_C               0x02

#define BIT_B               0x01

#define BIT_SC              0x08

#define BIT_SR              0x01

#define BIT_RL              0x04

#define BIT_DL              0x10

#define BIT_RE              0x04

#define BIT_G               0x02

#define BIT_BUSY            0x80

#define MASK_CGRAM_ADR      0x3F

#define MASK_DDRAM_ADR      0x3F

#define MASK_SCROLL_ADR     0x3F

#define MASK_GDRAM_ADR_HOR  0x0F

#define MASK_GDRAM_ADR_VER  0x3F

#define PORT_BL     PORTA

#define DDR_BL      DDRA

#define BIT_BL      PA0

//#define BL_PIN_USED

#ifdef INTERFACE_8_BIT

#define PORT_D0     PORTD

#define PIN_D0      PIND

#define DDR_D0      DDRD

#define BIT_D0      PC1

#define PORT_D1     PORTD

#define PIN_D1      PIND

#define DDR_D1      DDRD

#define BIT_D1      PD3

#define PORT_D2     PORTD

#define PIN_D2      PIND

#define DDR_D2      DDRD

#define BIT_D2      PD0

#define PORT_D3     PORTD

#define PIN_D3      PIND

#define DDR_D3      DDRD

#define BIT_D3      PD4

#endif

#define PORT_D4     PORTC

#define PIN_D4      PINC

#define DDR_D4      DDRC

#define BIT_D4      PC0

#define PORT_D5     PORTC

#define PIN_D5      PINC

#define DDR_D5      DDRC

#define BIT_D5      PC1

#define PORT_D6     PORTC

#define PIN_D6      PINC

#define DDR_D6      DDRC

#define BIT_D6      PC2

#define PORT_D7     PORTC

#define PIN_D7      PINC

#define DDR_D7      DDRC

#define BIT_D7      PC3

#define PORT_E      PORTB

#define DDR_E       DDRB

#define BIT_E       PB2

#define PORT_RW     PORTB

#define DDR_RW      DDRB

#define BIT_RW      PB3

#define PORT_RS     PORTB

#define DDR_RS      DDRB

#define BIT_RS      PB1

#define PORT_RES    PORTB

#define DDR_RES     DDRB

#define BIT_RES     PB1

//#define RESET_PIN_USED

#define RS_DATA     1

#define RS_CMD      0

static uint8_t G_ExtendedMode = 0;

static void RS (uint8_t val)

{

    if (val)

        PORT_RS |= (1<<BIT_RS);

    else

        PORT_RS &= ~(1<<BIT_RS);

}

static void E (uint8_t val)

{

    if (val)

        PORT_E  |= (1<<BIT_E);

    else

        PORT_E &= ~(1<<BIT_E);

}

static void RW (uint8_t val)

{

    if (val)

        PORT_RW |= (1<<BIT_RW);

    else

        PORT_RW &= ~(1<<BIT_RW);

}

#ifdef RESET_PIN_USED

static void RES (uint8_t val)

{

    if (val)

        PORT_RES |= (1<<BIT_RES);

    else

        PORT_RES &= ~(1<<BIT_RES);

}

#endif

#ifdef BL_PIN_USED

static void Backlight (uint8_t val)

{

    if (val)

        PORT_BL |= (1<<BIT_BL);

    else

        PORT_BL &= ~(1<<BIT_BL);

}

#endif

__attribute__ ((noinline)) void Delay (uint32_t dval)

{

    while (dval--)

        DELAY_1US;

}

//-------------------------------------------------------------------------------------------------

//

//-------------------------------------------------------------------------------------------------

static void GLCD_InitPorts(void)

{

    RS(0);

    RW(1);

    E(0);

#ifdef RESET_PIN_USED

    RES(1);

    DDR_RES |= (1<<BIT_RES);

#endif

    DDR_E   |= (1<<BIT_E);

    DDR_RW  |= (1<<BIT_RW);

    DDR_RS  |= (1<<BIT_RS);

#ifdef INTERFACE_8_BIT

    DDR_D0  &= ~(1<<BIT_D0);

    DDR_D1  &= ~(1<<BIT_D1);

    DDR_D2  &= ~(1<<BIT_D2);

    DDR_D3  &= ~(1<<BIT_D3);

#endif

    DDR_D4  &= ~(1<<BIT_D4);

    DDR_D5  &= ~(1<<BIT_D5);

    DDR_D6  &= ~(1<<BIT_D6);

    DDR_D7  &= ~(1<<BIT_D7);

}

static void SetDataOutput (void)

{

    #ifdef INTERFACE_8_BIT

    DDR_D0  |= (1<<BIT_D0);

    DDR_D1  |= (1<<BIT_D1);

    DDR_D2  |= (1<<BIT_D2);

    DDR_D3  |= (1<<BIT_D3);

    #endif

    DDR_D4  |= (1<<BIT_D4);

    DDR_D5  |= (1<<BIT_D5);

    DDR_D6  |= (1<<BIT_D6);

    DDR_D7  |= (1<<BIT_D7);

}

static void SetDataInput (void)

{

#ifdef INTERFACE_8_BIT

    DDR_D0  &= ~(1<<BIT_D0);

    DDR_D1  &= ~(1<<BIT_D1);

    DDR_D2  &= ~(1<<BIT_D2);

    DDR_D3  &= ~(1<<BIT_D3);

#endif

    DDR_D4  &= ~(1<<BIT_D4);

    DDR_D5  &= ~(1<<BIT_D5);

    DDR_D6  &= ~(1<<BIT_D6);

    DDR_D7  &= ~(1<<BIT_D7);

}

static void DataOut (uint8_t data)

{

#ifdef INTERFACE_8_BIT

    if (data&0x01) PORT_D0 |= (1<<BIT_D0); else PORT_D0 &= ~(1<<BIT_D0);

    if (data&0x02) PORT_D1 |= (1<<BIT_D1); else PORT_D1 &= ~(1<<BIT_D1);

    if (data&0x04) PORT_D2 |= (1<<BIT_D2); else PORT_D2 &= ~(1<<BIT_D2);

    if (data&0x08) PORT_D3 |= (1<<BIT_D3); else PORT_D3 &= ~(1<<BIT_D3);

    if (data&0x10) PORT_D4 |= (1<<BIT_D4); else PORT_D4 &= ~(1<<BIT_D4);

    if (data&0x20) PORT_D5 |= (1<<BIT_D5); else PORT_D5 &= ~(1<<BIT_D5);

    if (data&0x40) PORT_D6 |= (1<<BIT_D6); else PORT_D6 &= ~(1<<BIT_D6);

    if (data&0x80) PORT_D7 |= (1<<BIT_D7); else PORT_D7 &= ~(1<<BIT_D7);

#else

    if (data&0x01) PORT_D4 |= (1<<BIT_D4); else PORT_D4 &= ~(1<<BIT_D4);

    if (data&0x02) PORT_D5 |= (1<<BIT_D5); else PORT_D5 &= ~(1<<BIT_D5);

    if (data&0x04) PORT_D6 |= (1<<BIT_D6); else PORT_D6 &= ~(1<<BIT_D6);

    if (data&0x08) PORT_D7 |= (1<<BIT_D7); else PORT_D7 &= ~(1<<BIT_D7);

#endif

    SetDataOutput();

}

static uint8_t DataIn (void)

{

    uint8_t data=0;

#ifdef INTERFACE_8_BIT

    PORT_D0 &= ~(1<<BIT_D0);

    PORT_D1 &= ~(1<<BIT_D1);

    PORT_D2 &= ~(1<<BIT_D2);

    PORT_D3 &= ~(1<<BIT_D3);

#endif

    PORT_D4 &= ~(1<<BIT_D4);

    PORT_D5 &= ~(1<<BIT_D5);

    PORT_D6 &= ~(1<<BIT_D6);

    PORT_D7 &= ~(1<<BIT_D7);

    SetDataInput();

    data = (data<<1) | ((PIN_D7>>BIT_D7)&1);

    data = (data<<1) | ((PIN_D6>>BIT_D6)&1);

    data = (data<<1) | ((PIN_D5>>BIT_D5)&1);

    data = (data<<1) | ((PIN_D4>>BIT_D4)&1);

#ifdef INTERFACE_8_BIT

    data = (data<<1) | ((PIN_D3>>BIT_D3)&1);

    data = (data<<1) | ((PIN_D2>>BIT_D2)&1);

    data = (data<<1) | ((PIN_D1>>BIT_D1)&1);

    data = (data<<1) | ((PIN_D0>>BIT_D0)&1);

#endif

    return(data);

}

//-------------------------------------------------------------------------------------------------

// Read

//-------------------------------------------------------------------------------------------------

static uint8_t GLCD_rawRead(uint8_t regsel)

{

    uint8_t tmp;

    E(0);

    SetDataInput();

    RS(regsel);

    RW(1);

    Delay(1);

    E(1);

    Delay(1);

    tmp = DataIn();

    E(0);

    Delay(1);

#ifndef INTERFACE_8_BIT

    E(1);

    Delay(1);

    tmp <<= 4;

    tmp |= DataIn();

    E(0);

    Delay(1);

#endif

    return tmp;

}

//-------------------------------------------------------------------------------------------------

// Wait Busy

//-------------------------------------------------------------------------------------------------

static void GLCD_WaitBusy(void)

{

    while(GLCD_rawRead(0)&BIT_BUSY);

}

//-------------------------------------------------------------------------------------------------

// Read

//-------------------------------------------------------------------------------------------------

static uint8_t GLCD_Read(uint8_t regsel)

{

    uint8_t tmp;

    E(0);

    SetDataInput();

    RS(regsel);

    RW(1);

    Delay(1);

    E(1);

    Delay(1);

    tmp = DataIn();

    E(0);

    Delay(1);

#ifndef INTERFACE_8_BIT

    E(1);

    Delay(1);

    tmp <<= 4;

    tmp |= DataIn();

    E(0);

    Delay(1);

#endif

    GLCD_WaitBusy();

    return tmp;

}

//-------------------------------------------------------------------------------------------------

// Write

//-------------------------------------------------------------------------------------------------

static void GLCD_Write(uint8_t regsel, uint8_t val)

{

    SetDataOutput();

    RS(regsel);

    RW(0);

#ifdef INTERFACE_8_BIT

    DataOut(val);

    Delay(1);

    E(1);

    Delay(1);

    E(0);

#else

    DataOut(val>>4);

    Delay(1);

    E(1);

    Delay(1);

    E(0);

    DataOut(val&0xF);

    Delay(1);

    E(1);

    Delay(1);

    E(0);

#endif

    RW(1);

    RS(1);

    SetDataInput();

    GLCD_WaitBusy();

}

//-------------------------------------------------------------------------------------------------

// BasicMode

//-------------------------------------------------------------------------------------------------

static void GLCD_SetBasicMode(void)

{

    if (G_ExtendedMode)

    {

#ifdef INTERFACE_8_BIT

        GLCD_Write(RS_CMD,CMD_FUNCTION_SET|BIT_DL);

#else

        GLCD_Write(RS_CMD,CMD_FUNCTION_SET);

#endif

        G_ExtendedMode = 0;

    }

}

//-------------------------------------------------------------------------------------------------

// ExtendedMode

//-------------------------------------------------------------------------------------------------

static void GLCD_SetExtendedMode(void)

{

    if (!G_ExtendedMode)

    {

#ifdef INTERFACE_8_BIT

        GLCD_Write(RS_CMD,CMD_FUNCTION_SET|BIT_DL|BIT_RE|BIT_G);

#else

        GLCD_Write(RS_CMD,CMD_FUNCTION_SET|BIT_RE|BIT_G);

#endif

        G_ExtendedMode = 1;

    }

}

//-------------------------------------------------------------------------------------------------

// ClearTXT

//-------------------------------------------------------------------------------------------------

void GLCD_ClearTXT(void)

{

    GLCD_SetBasicMode();

    GLCD_Write(RS_CMD,CMD_DISPLAY_CLEAR);

    GLCD_WaitBusy();

}

//-------------------------------------------------------------------------------------------------

// ClearGFX

//-------------------------------------------------------------------------------------------------

void GLCD_ClearGFX(void)

{

    uint8_t x,y;

    GLCD_SetExtendedMode();

    GLCD_Write(RS_CMD,CMDE_SET_GDRAM_ADR);

    GLCD_Write(RS_CMD,CMDE_SET_GDRAM_ADR);

    for (y=0;y<64;y++)

    {

        GLCD_Write(RS_CMD,CMDE_SET_GDRAM_ADR|(MASK_GDRAM_ADR_VER&y));

        GLCD_Write(RS_CMD,CMDE_SET_GDRAM_ADR);

        for (x=0;x<32;x++)

            GLCD_Write(RS_DATA,0x0);

    }

}

//-------------------------------------------------------------------------------------------------

// SetPixel

//-------------------------------------------------------------------------------------------------

void GLCD_SetPixel(uint8_t x,uint8_t y, uint8_t color)

{

    uint8_t subpos;

    uint8_t pix;

    uint8_t pixel_low;

    uint8_t pixel_high;

    GLCD_SetExtendedMode();

    GLCD_Write(RS_CMD,CMDE_SET_GDRAM_ADR|(MASK_GDRAM_ADR_VER&y));

    GLCD_Write(RS_CMD,CMDE_SET_GDRAM_ADR|(MASK_GDRAM_ADR_HOR&(x>>4)));

    GLCD_Read(RS_DATA);

    pixel_high  = GLCD_Read(RS_DATA);

    pixel_low   = GLCD_Read(RS_DATA);

    subpos = x & 0x0F;

    GLCD_Write(RS_CMD,CMDE_SET_GDRAM_ADR|(MASK_GDRAM_ADR_VER&y));

    GLCD_Write(RS_CMD,CMDE_SET_GDRAM_ADR|(MASK_GDRAM_ADR_HOR&(x>>4)));

    if (subpos < 8)

    {

        pix = color ? (1<<(7-subpos))|pixel_high : (~(1<<(7-subpos)))&pixel_high;

        GLCD_Write(RS_DATA,pix);

        GLCD_Write(RS_DATA,pixel_low);

    }

    else

    {

        pix = color ? (1<<(15-subpos))|pixel_low : (~(1<<(7-subpos)))&pixel_low;

        GLCD_Write(RS_DATA,pixel_high);

        GLCD_Write(RS_DATA,pix);

    }

}

//-------------------------------------------------------------------------------------------------

// Vertical Offset

//-------------------------------------------------------------------------------------------------

void GLCD_VerticalOffset(uint8_t offs)

{

    GLCD_SetExtendedMode();

    GLCD_Write(RS_CMD,CMDE_SCROLL_SEL|BIT_SR);

    GLCD_Write(RS_CMD,CMDE_SET_SCROLL_ADR|(MASK_SCROLL_ADR&offs));

    GLCD_Write(RS_CMD,CMDE_SCROLL_SEL);

    GLCD_WaitBusy();

}

//-------------------------------------------------------------------------------------------------

//

//-------------------------------------------------------------------------------------------------

void GLCD_WriteString(uint8_t x, uint8_t y,char * s)

{

    GLCD_SetBasicMode();

    GLCD_Write(RS_CMD,CMD_SET_DDRAM_ADR|(y*16+(x&0x1E)));

    if (x&1)

        GLCD_Write(RS_DATA,' ');

    while(*s)

    {

        GLCD_Write(RS_DATA,*s);

        s++;

    }

}

//-------------------------------------------------------------------------------------------------

//

//-------------------------------------------------------------------------------------------------

void GLCD_Init(void)

{

    GLCD_InitPorts();

#ifdef RESET_PIN_USED

    RES(0);

    Delay(10000);

    RES(1);

#endif

    Delay(100000);

#ifdef INTERFACE_8_BIT

    GLCD_Write(RS_CMD,CMD_FUNCTION_SET|BIT_DL);

    GLCD_Write(RS_CMD,CMD_FUNCTION_SET|BIT_DL);

#else

    GLCD_Write(RS_CMD,CMD_FUNCTION_SET);

    GLCD_Write(RS_CMD,CMD_FUNCTION_SET);

#endif

    GLCD_Write(RS_CMD,CMD_DISPLAY_CONTROL|BIT_D);

    Delay(100);

    GLCD_Write(RS_CMD,CMD_DISPLAY_CLEAR);

    Delay(100);

    GLCD_Write(RS_CMD,CMD_ENTRY_MODE|BIT_ID);

    Delay(100);

    G_ExtendedMode = 0;

}