/*-------------------------------------------------------------------------------
The function is for LCD1602 4 bit operation 
In the main function you only need to use these function which are listing behind
Design By: U-easytech
Data:13/03/2008

_-------------------------------------------------------------------------------*/
#include <stm32f10x_lib.h>              /* STM32F10x Library Definitions      */
void lcd_init     (void);		  //初始化LCD1602及相應I/O PORTS
void lcd_clear    (void);		  //清屏
void lcd_putchar  (char c);
void set_cursor   (int column, int line);
void lcd_print     (char *string);	 //顯示
void lcd_bargraph (int pos_x, int pos_y, int value);	//顯示

/******************************************************************************/

/*********************** Hardware specific configuration **********************/

/*------------------------- Speed dependant settings -------------------------*/

/* If processor works on high frequency delay has to be increased, it can be 
   increased by factor 2^N by this constant                                   */
#define DELAY_2N     0

/*------------------------- Text LCD size definitions ------------------------*/

#define LineLen     16                  /* Width (in characters)              */
#define NumLines     2                  /* Hight (in lines)                   */

/*-------------------- LCD interface hardware definitions --------------------*/

/* PINS: 
   - DB4 = 	 PB12
   - DB5 = 	 PB13      
   - DB6 = 	 PB14
   - DB7 = 	 PB15
   - E   =   PB5
   - RW  =   PB6
   - RS  =   PB7                                                  */

#define PIN_E                 (   1 << 5)
#define PIN_RW                (   1 << 6)
#define PIN_RS                (   1 << 7)
#define PINS_CTRL             0x00E0
#define PINS_DATA             0xF000
#define PINS_ALL              (PINS_CTRL | PINS_DATA)
//const unsigned int SWAP_DATA[16] = { 0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE, 
//                                  0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF};
 const unsigned int SWAP_DATA[16]={0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xA,0xB,0xc,0xd,0xe,0xF	} ;
/* Enable Clock for peripheral driving LCD pins                               */
#define LCD_CLOCK_EN          RCC_APB2PeriphClockCmd (RCC_APB2Periph_GPIOB, ENABLE);

/* pin E  setting to 0 or 1                                                   */
#define LCD_E(x)              GPIOB->ODR = (GPIOB->ODR & ~PIN_E)  | (x ? PIN_E : 0);
/* pin RW setting to 0 or 1                                                   */
#define LCD_RW(x)             GPIOB->ODR = (GPIOB->ODR & ~PIN_RW) | (x ? PIN_RW : 0);
/* pin RS setting to 0 or 1                                                   */
#define LCD_RS(x)             GPIOB->ODR = (GPIOB->ODR & ~PIN_RS) | (x ? PIN_RS : 0);

/* Reading DATA pins                                                          */

#define LCD_DATA_IN           SWAP_DATA[(((GPIOB->IDR & PINS_DATA) >> 12) & 0x0F)]
/* Writing value to DATA pins                                                 */

#define LCD_DATA_OUT(x)       GPIOB->ODR = (GPIOB->ODR & ~PINS_DATA) | ((SWAP_DATA[x]) << 12);
																			   
/* Setting all pins to output mode                                            */
#define LCD_ALL_DIR_OUT       GPIOB->CRL = (GPIOB->CRL & 0x000FFFFF) | 0x33300000; \
                              GPIOB->CRH = (GPIOB->CRH & 0x0000FFFF) | 0x33330000;
 
/* Setting DATA pins to input mode                                            */
#define LCD_DATA_DIR_IN       GPIOB->CRH = (GPIOB->CRH & 0x0000FFFF) | 0x44440000;

/* Setting DATA pins to output mode                                           */
#define LCD_DATA_DIR_OUT      GPIOB->CRH = (GPIOB->CRH & 0x0000FFFF) | 0x33330000;

/******************************************************************************/



/*******************************************************************************
* Delay in while loop cycles                                                   *
*   Parameter:    cnt:    number of while cycles to delay                      *
*   Return:                                                                    *
*******************************************************************************/

static void delay (int cnt)
{
  cnt <<= DELAY_2N;

  while (cnt--);
}


/*******************************************************************************
* Read status of LCD controller                                                *
*   Parameter:    none                                                         *
*   Return:       Status byte contains busy flag and address pointer           *
*******************************************************************************/

static unsigned char lcd_read_status (void)
{
  unsigned char status;

  LCD_DATA_DIR_IN
  LCD_RS(0)
  LCD_RW(1)
  delay(10);
  LCD_E(1)
  delay(10);
  status  = LCD_DATA_IN << 4;
  LCD_E(0)
  delay(10);
  LCD_E(1)
  delay(10);
  status |= LCD_DATA_IN;
  LCD_E(0)
  LCD_DATA_DIR_OUT
  return (status);
}


/*******************************************************************************
* Wait until LCD controller busy flag is 0                                     *
*   Parameter:                                                                 *
*   Return:       Status byte of LCD controller (busy + address)               *
*******************************************************************************/

static unsigned char wait_while_busy (void)
{
  unsigned char status;

  do  {
    status = lcd_read_status();
  }  while (status & 0x80);             /* Wait for busy flag                 */

  return (status);
}


/*******************************************************************************
* Write 4-bits to LCD controller                                               *
*   Parameter:    c:      command to be written                                *
*   Return:                                                                    *
*******************************************************************************/

void lcd_write_4bit (unsigned char c)
{
  LCD_RW(0)
  LCD_E(1)
  LCD_DATA_OUT(c&0x0F)
  delay(10);
  LCD_E(0)
  delay(10);
}


/*******************************************************************************
* Write command to LCD controller                                              *
*   Parameter:    c:      command to be written                                *
*   Return:                                                                    *
*******************************************************************************/

void lcd_write_cmd (unsigned char c)
{
  wait_while_busy();

  LCD_RS(0)
  lcd_write_4bit (c>>4);
  lcd_write_4bit (c);
}


/*******************************************************************************
* Write data to LCD controller                                                 *
*   Parameter:    c:      data to be written                                   *
*   Return:                                                                    *
*******************************************************************************/

static void lcd_write_data (unsigned char c)
{
  wait_while_busy();

  LCD_RS(1)
  lcd_write_4bit (c>>4);
  lcd_write_4bit (c);
}


/*******************************************************************************
* Print Character to current cursor position                                   *
*   Parameter:    c:      character to be printed                              *
*   Return:                                                                    *
*******************************************************************************/

void lcd_putchar (char c)
{ 
  lcd_write_data (c);
}


/*******************************************************************************
* Initialize the LCD controller                                                *
*   Parameter:                                                                 *
*   Return:                                                                    *
*******************************************************************************/

void lcd_init (void)
{ 
 

  LCD_CLOCK_EN                          /* Enable clock for peripheral        */

  /* Set all pins for LCD as outputs                                          */
  LCD_ALL_DIR_OUT

  delay (15000);
  LCD_RS(0)
  lcd_write_4bit (0x3);                 /* Select 4-bit interface             */
  delay (4100);
  lcd_write_4bit (0x3);
  delay (100);
  lcd_write_4bit (0x3);
  lcd_write_4bit (0x2);

  lcd_write_cmd (0x28);                 /* 2 lines, 5x8 character matrix      */
  lcd_write_cmd (0x0C);                 /* Display ctrl:Disp=ON,Curs/Blnk=OFF */
  lcd_write_cmd (0x0E);                 /* Entry mode: Move right, no shift   */

  /* Load user-specific characters into CGRAM                                 */
 // lcd_write_cmd(0x40);                  /* Set CGRAM address counter to 0     */
 // p = &UserFont[0][0];
  //for (i = 0; i < sizeof(UserFont); i++, p++)
  //  lcd_putchar (*p);

  lcd_write_cmd(0x80);                  /* Set DDRAM address counter to 0     */
}


/*******************************************************************************
* Set cursor position on LCD display                                           *
*   Parameter:    column: column position                                      *
*                 line:   line position                                        *
*   Return:                                                                    *
*******************************************************************************/

void set_cursor (int column, int line)
{
  unsigned char address;

  address = (line * 40) + column;
  address = 0x80 + (address & 0x7F);
  lcd_write_cmd(address);               /* Set DDRAM address counter to 0     */
}

/*******************************************************************************
* Clear the LCD display                                                        *
*   Parameter:                                                                 *
*   Return:                                                                    *
*******************************************************************************/

void lcd_clear (void)
{
  lcd_write_cmd(0x01);                  /* Display clear                      */
  set_cursor (0, 0);
}


/*******************************************************************************
* Print sting to LCD display                                                   *
*   Parameter:    string: pointer to output string                             *
*   Return:                                                                    *
*******************************************************************************/

void lcd_print (char *string)
{
  while (*string)  {
    lcd_putchar (*string++);
  }
}


/*******************************************************************************
* Display bargraph on LCD display                                              *
*   Parameter:     pos_x: horizontal position of bargraph start                *
*                  pos_y: vertical position of bargraph                        *
*                  value: size of bargraph active field (in pixels)            *
*   Return:                                                                    *
*******************************************************************************/

void lcd_bargraph (int pos_x, int pos_y, int value) {
  int i;

  set_cursor (pos_x, pos_y);
  for (i = 0; i < 16; i++)  {
    if (value > 5) {
      lcd_putchar (0x05);
      value -= 5;
    } else {
      lcd_putchar (value);
      while (i++ < 16) lcd_putchar (0);
    }
  }
}

/******************************************************************************/