AVRFreaks.net

// ************************************************************
//                          L C D - R O U T I N E S
//         for Electronic Assembly's DOGM LCD series
//                      -- Header-File --
// ************************************************************
//
//    Author:         Mario Richter
//    File:         dogm.h
//    Project:      Routines for DOGM LCD series
//    Date:           March 2009
//    Target MCU:   not specified
//
// DESCRIPTION
//
//    Routines for the DOGMxxx LCD series by Electonic Assembly
//  with ST7036 controller.
//
// ************************************************************

#ifndef __DOGM__
#define __DOGM__

#include <util/delay.h>

// Port Definitions -- change to suit your application
// ------------------------------------------------------------

#define DOGM_D4_PORT      PORTA
#define DOGM_D4_PIN       (1<<PA3)

#define DOGM_D5_PORT      PORTA
#define DOGM_D5_PIN       (1<<PA2)

#define DOGM_D6_PORT      PORTA
#define DOGM_D6_PIN       (1<<PA1)

#define DOGM_D7_PORT      PORTA
#define DOGM_D7_PIN       (1<<PA0)

#define DOGM_E_PORT       PORTD
#define DOGM_E_PIN        (1<<PD4)

#define DOGM_RW_PORT      PORTD
#define DOGM_RW_PIN       (1<<PD5)

#define DOGM_RS_PORT      PORTD
#define DOGM_RS_PIN       (1<<PD6)


// DDR(x) and PIN(x) macros - taken from Peter Fleury's LCD routines
// ------------------------------------------------------------

#define DDR(x) (*(&x - 1))      /* address of data direction register of port x */
#if defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__)
    /* on ATmega64/128 PINF is on port 0x00 and not 0x60 */
    #define PIN(x) ( &PORTF==&(x) ? _SFR_IO8(0x00) : (*(&x - 2)) )
#else
   #define PIN(x) (*(&x - 2))    /* address of input register of port x          */
#endif


// Function Declarations
// ------------------------------------------------------------

void dogm_init(void);                         // Initialize LCD
void dogm_putc(char);                         // Write character to display
void dogm_puts(char *);                       // Write string to display
void dogm_gotoxy(uint8_t, uint8_t);           // Go to position
void dogm_clear(void);                        // Clear display, go to first char in first line

// Internal routines
void dogm_port_init(void);                    // Initialize ports for LCD module
void dogm_write_check(uint8_t, uint8_t);      // Do busy check and write 8 bit to LCD
void dogm_write_nocheck(uint8_t, uint8_t);    // Write 8 bit to LCD without busy check
void dogm_write_once(uint8_t);                // Write 4 bit to LCD without busy check
void dogm_chk_busy(void);                     // Busy Check

#endif

// ************************************************************
//                          L C D - R O U T I N E S
//         for Electronic Assembly's DOGM LCD series
// ************************************************************
//
//  Version:    0.10 (2009-03-17)
//
//    Author:         Mario Richter
//    File:         dogm.c
//    Project:      Routines for DOGM LCD series
//    Date:           March 2009
//    Target MCU:   not specified
//
// DESCRIPTION
//
//    Routines for the DOGMxxx LCD series by Electonic Assembly
//  with ST7036 controller. Port connections are specified in
//  dogm.h header file.
//
// ************************************************************

#include <avr/io.h>                        // Aliases for IO ports etc.
#include <stdint.h>                        // Standard data types

#include "dogm.h"


// ************************************************************
// Initialize LCD module
// ************************************************************

void dogm_init(void)
{
  dogm_port_init();                     // initialize ports

  _delay_ms(400);                       // 40ms delay
  dogm_write_once(0x30);                // Function Set #1: DL=1
  _delay_ms(2);                         // 2ms delay
  dogm_write_once(0x30);                // Function Set #2: DL=1

  _delay_ms(30);                        // 30us delay
  dogm_write_once(0x30);                // Function Set #3: DL=1
  _delay_ms(100);                        // 30us delay

  dogm_chk_busy();                      // Check busy flag
  dogm_write_once(0x20);                // Function Set #4: DL=0

  _delay_ms(30);                        // 30us delay
  dogm_write_check(0, 0x29);            // Function Set #5: DL=0, N=1, IS2=0, IS1=1
  _delay_ms(30);                        // 30us delay

  dogm_write_check(0, 0x15);            // Bias Set: BS=0, FX=0
  _delay_ms(30);                        // 30us delay

  dogm_write_check(0, 0x72);            // Contrast Set: C3=1, C2=C1=C0=0
  _delay_ms(30);                        // 30us delay

  dogm_write_check(0, 0x55);            // Power/ICON/Contrast: Icon=1, Bon=1, C5=1, C4=0
  _delay_ms(30);                        // 30us delay

  dogm_write_check(0, 0x6E);            // Follower Ctrl: Fon=1, Rab2=0, Rab1=1, Rab0=0
  _delay_ms(30);                        // 30us delay

  dogm_write_check(0, 0x0C);            // DISPLAY ON: D=1, C=0, B=0
  _delay_ms(30);                        // 30us delay

  dogm_write_check(0, 0x01);            // CLEAR DISPLAY
  _delay_ms(2);                         // 2ms delay

  dogm_write_check(0, 0x06);            // Entry mode set: I/D=1, S=0
  _delay_ms(30);                        // 30us delay
}


// ************************************************************
// Write single character to display
// ************************************************************

void dogm_putc(char c)
{
  dogm_write_check(1, c);
}


// ************************************************************
// Write string to display
// ************************************************************

void dogm_puts(char * str)
{
  while(*str != '\0')
    dogm_putc(*str++);
}


// ************************************************************
// Go to position xy
// ************************************************************

void dogm_gotoxy(uint8_t x, uint8_t y)
{
  uint8_t addr;

  addr = (y * 0x40) + x;
  dogm_write_check(0, 0x80 | addr);
}


// ************************************************************
// Clear display
// ************************************************************

void dogm_clear()
{
  dogm_write_check(0, 0x01);
}


// ************************************************************
// Initialize ports for LCD module
// ************************************************************

void dogm_port_init(void)
{
  DDRD = 0;
  DDR(DOGM_E_PORT)  |= DOGM_E_PIN;
  DDR(DOGM_RS_PORT) |= DOGM_RS_PIN;
  DDR(DOGM_RW_PORT) |= DOGM_RW_PIN;

  DDR(DOGM_D4_PORT) |= DOGM_D4_PIN;
  DDR(DOGM_D5_PORT) |= DOGM_D5_PIN;
  DDR(DOGM_D6_PORT) |= DOGM_D6_PIN;
  DDR(DOGM_D7_PORT) |= DOGM_D7_PIN;
}


// ************************************************************
// Busy Check
// ************************************************************

void dogm_chk_busy(void)
{
  uint8_t busy = 1;

  // Configure LCD data ports as inputs
  DDR(DOGM_D4_PORT) &= ~DOGM_D4_PIN;
  DDR(DOGM_D5_PORT) &= ~DOGM_D5_PIN;
  DDR(DOGM_D6_PORT) &= ~DOGM_D6_PIN;
  DDR(DOGM_D7_PORT) &= ~DOGM_D7_PIN;

  // Set RW high to read busy flag
  DOGM_RW_PORT  |= DOGM_RW_PIN;

  // Set RS low to read from control registers
  DOGM_RS_PORT  &= ~DOGM_RS_PIN;

  // Loop while LCD is busy
  while(busy)
  {
    // Get upper 4 bits, D7 is busy flag
    DOGM_E_PORT |= DOGM_E_PIN;
    _delay_us(2);
    busy = PINA & DOGM_D7_PIN;
    DOGM_E_PORT &= ~DOGM_E_PIN;

    // Get lower 4 bits
    DOGM_E_PORT |= DOGM_E_PIN;
    _delay_us(2);
    DOGM_E_PORT &= ~DOGM_E_PIN;
  }

  // Set RW low to write to LCD again
  DOGM_RW_PORT  &= ~DOGM_RW_PIN;

  // Configure LCD data ports as outputs
  DDR(DOGM_D4_PORT) |= DOGM_D4_PIN;
  DDR(DOGM_D5_PORT) |= DOGM_D5_PIN;
  DDR(DOGM_D6_PORT) |= DOGM_D6_PIN;
  DDR(DOGM_D7_PORT) |= DOGM_D7_PIN;
}


// ************************************************************
// Do busy check and write 8 bit to LCD
// ************************************************************

void dogm_write_check(uint8_t rs, uint8_t data)
{
  dogm_chk_busy();               // check busy flag
  dogm_write_nocheck(rs, data);   // write 8 bit data to LCD
}


// ************************************************************
// Write 8 bit to LCD without busy check
// ************************************************************

void dogm_write_nocheck(uint8_t rs, uint8_t data)
{
  // if target is control register (rs=0), clear RS output, else set it
  if(rs)
    DOGM_RS_PORT  |= DOGM_RS_PIN;
  else
    DOGM_RS_PORT  &= ~DOGM_RS_PIN;

  dogm_write_once(data);          // write upper 4 bit to LCD
  dogm_write_once(data << 4);     // write lower 4 bit to LCD
}


// ************************************************************
// Write 4 bit to LCD without busy check
// Upper 4 bits of data are used as D7..D4
// ************************************************************

void dogm_write_once(uint8_t data)
{
  // Clear RW
  DOGM_RW_PORT  &= ~DOGM_RW_PIN;

  // D7
  if(data & 0x80)
    DOGM_D7_PORT  |= DOGM_D7_PIN;
  else
    DOGM_D7_PORT  &= ~DOGM_D7_PIN;

  // D6
  if(data & 0x40)
    DOGM_D6_PORT  |= DOGM_D6_PIN;
  else
    DOGM_D6_PORT  &= ~DOGM_D6_PIN;

  // D5
  if(data & 0x20)
    DOGM_D5_PORT  |= DOGM_D5_PIN;
  else
    DOGM_D5_PORT  &= ~DOGM_D5_PIN;

  // D4
  if(data & 0x10)
    DOGM_D4_PORT  |= DOGM_D4_PIN;
  else
    DOGM_D4_PORT  &= ~DOGM_D4_PIN;

  // Generate enable impulse
  DOGM_E_PORT   |= DOGM_E_PIN;
  _delay_us(2);
  DOGM_E_PORT   &= ~DOGM_E_PIN;
}

void dogm_puts(char * str)
{
  cli();
  while(*str != '\0')
    dogm_putc(*str++);
  sei();
}

ATOMIC_BLOCK(ATOMIC_FORCEON)
{
  // Set RW high to read busy flag
  DOGM_RW_PORT  |= DOGM_RW_PIN;

  // Set RS low to read from control registers
  DOGM_RS_PORT  &= ~DOGM_RS_PIN;
}