FreeRTOS/Demo/RX200_RX210-RSK_Renesas/RTOSDemo/Renesas-Files/hd44780.c - third_party/github/FreeRTOS/FreeRTOS-Kernel - Git at Google

 /*------------------------------------------------------------------------/
 /  EZ-LCD - Generic control module for HD44780 LCDC - R0.01c
 /-------------------------------------------------------------------------/
 /
 /  Copyright (C) 2010, ChaN, all right reserved.
 /
 / * This software is a free software and there is NO WARRANTY.
 / * No restriction on use. You can use, modify and redistribute it for
 /   personal, non-profit or commercial products UNDER YOUR RESPONSIBILITY.
 / * Redistributions of source code must retain the above copyright notice.
 /
 /-------------------------------------------------------------------------/
 / Nov 12,'10 R0.01c  First release.
 /------------------------------------------------------------------------*/
 #include <machine.h>
 #include "hd44780.h"

 /*-------------------------------------------------------------------------*/
 /* Platform dependent macros and functions needed to be modified           */
 /*-------------------------------------------------------------------------*/

 /* Bus controls */
 #include "iodefine.h"			/* Device specific include file */
 #include "rskrx210def.h"

 #define	IF_BUS		4			/* Data bus width (4 or 8) */
 #define	IF_INIT()	{}			/* Initialize control port */
 #define E1_HIGH()	LCD_EN = 1	/* Set E(E1) high */
 #define E1_LOW()	LCD_EN = 0  /* Set E(E1) low */
 #define E2_HIGH()				/* Set E2 high (dual controller only) */
 #define E2_LOW()				/* Set E2 low (dual controller only) */
 #define	RS_HIGH()	LCD_RS = 1	/* Set RS high */
 #define	RS_LOW()	LCD_RS = 0	/* Set RS low */
 #define	OUT_DATA(d)	LCD_DATA = (d & 0x0F)//LCD_DATA = ((LCD_DATA & 0xF0) | (d & 0x0F))	/* Output a byte d on the data bus (higher 4 bits of d in 4-bit mode) */
 #define	IF_DLY60()	{nop();nop();nop(); }			/* Delay >=60ns (can be blanked for most uC) */
 #define	IF_DLY450()	{unsigned long x; for(x=0; x<22; x++){nop();}}			/* Delay >=450ns@3V, >=250ns@5V */
 #define DELAY_US(n)	{unsigned long x; for(x=0; x<(n*50); x++){nop();}}			/* Delay n microseconds */

 /* Characteristics of LCD module  */
 #define	LCD_ETIME_1	1530		/* Execution time of Clear Display command [us] */
 #define	LCD_ETIME_2	43			/* Execution time of other command and data write [us] */
 #define	LCD_DLF		2.0			/* Delay factor (>=2.0) */


 /*-------------------------------------------------------------------------*/


 #if _LCD_ROWS >= 2 || _LCD_COLS > 8
  #define LCD_IF_2ROW 8		/* 2-row cfg. */
  #if _LCD_ROWS == 1
   #define LCD_IF_SPLIT 1	/* Half split row */
  #else
   #define LCD_IF_SPLIT 0	/* Direct row */
  #endif
 #else
  #define LCD_IF_2ROW 0		/* 1-row cfg. */
 #endif

 #if _LCD_ROWS == 4 && _LCD_COLS <= 20
  #define LCD_IF_ALTROW	1	/* Alternate row layout */
 #else
  #define LCD_IF_ALTROW	0	/* Incremental row layout */
 #endif

 #if _LCD_ROWS == 4 && _LCD_COLS > 20
  #define LCD_IF_DUAL 	1	/* Dual controller */
 #else
  #define LCD_IF_DUAL 	0	/* Single controller */
 #endif

 #define	LCD_DT1		((uint16_t)(LCD_ETIME_1 * LCD_DLF))
 #define	LCD_DT2		((uint16_t)(LCD_ETIME_2 * LCD_DLF))


 static
 uint8_t Row, Column;	/* Current cursor position */
 #if _USE_CURSOR
 static
 uint8_t Csr;	/* Current cursor state */
 #endif


 /*----------------------------------------------*/
 /* Write a byte to the LCD controller           */
 /*----------------------------------------------*/

 static
 void lcd_write (
 	uint8_t reg,	/* b0:command(0)/data(1), b2..1:E1(2)/E2(1)/both(0)(don't care on single controller), b3:write high nibble only(don't care on 8-bit bus) */
 	uint8_t dat		/* Byte to be written */
 )
 {
 	if (reg & 1)	/* Select register */
 		RS_HIGH();
 	else
 		RS_LOW();
 	IF_DLY60();

 #if IF_BUS == 4
 	if (!(reg & 8)) {
 		OUT_DATA(dat);
 #if LCD_IF_DUAL
 		if (!(reg & 2)) E1_HIGH();
 		if (!(reg & 4)) E2_HIGH();
 		IF_DLY450();
 		E1_LOW();
 		E2_LOW();
 #else
 		E1_HIGH();
 		IF_DLY450();
 		E1_LOW();
 #endif
 		IF_DLY450();
 		dat <<= 4;
 	}
 #endif

 	OUT_DATA(dat);
 #if LCD_IF_DUAL
 	if (!(reg & 2)) E1_HIGH();
 	if (!(reg & 4)) E2_HIGH();
 	IF_DLY450();
 	E1_LOW();
 	E2_LOW();
 #else
 	E1_HIGH();
 	IF_DLY450();
 	E1_LOW();
 #endif

 	DELAY_US(LCD_DT2);	/* Always use timer */
 }


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

 void lcd_init (void)
 {
 	uint8_t d;

 	E1_HIGH();
 	DELAY_US(40000);
 	E1_LOW();

 //	IF_INIT();

 //	DELAY_US(40000);
 	lcd_write(8, 0x30);
 	DELAY_US(4100);
 	lcd_write(8, 0x30);
 	DELAY_US(100);
 	lcd_write(8, 0x30);

 	d = (IF_BUS == 4 ? 0x20 : 0x30) | LCD_IF_2ROW;
 	lcd_write(8, d);
 #if IF_BUS == 4
 	lcd_write(0, d);
 #endif
 	lcd_write(0, 0x08);
 	lcd_write(0, 0x01);
 	DELAY_US(LCD_DT1);
 	lcd_write(0, 0x06);
 	lcd_write(0, 0x0C);

 	Row = Column = 0;
 #if _USE_CURSOR
 	Csr = 0;
 #endif
 }


 /*-----------------------------------------------------------------------*/
 /* Set cursor position                                                   */
 /*-----------------------------------------------------------------------*/

 void lcd_locate (
 	uint8_t row,	/* Cursor row position (0.._LCD_ROWS-1) */
 	uint8_t col		/* Cursor column position (0.._LCD_COLS-1) */
 )
 {
 	Row = row; Column = col;

 	if (row < _LCD_ROWS && col < _LCD_COLS) {
 		if (_LCD_COLS >= 2 && (row & 1)) col += 0x40;
 		if (LCD_IF_SPLIT && col >= _LCD_COLS / 2) col += 0x40 - _LCD_COLS / 2;
 		if (LCD_IF_ALTROW && (row & 2)) col += _LCD_COLS;
 		col |= 0x80;
 	} else {
 		col = 0x0C;
 	}

 #if LCD_IF_DUAL
 	if (_USE_CURSOR && !(row &= 2)) row |= 4;
 	lcd_write(row, col);
 #if _USE_CURSOR
 	if (col != 0x0C) lcd_write(row, Csr | 0x0C);
 	row ^= 6;
 	lcd_write(row, 0x0C);
 #endif
 #else
 	lcd_write(0, col);
 #if _USE_CURSOR
 	if (col != 0x0C) lcd_write(0, Csr | 0x0C);
 #endif
 #endif
 }


 /*-----------------------------------------------------------------------*/
 /* Put a character                                                       */
 /*-----------------------------------------------------------------------*/

 void lcd_putc (
 	uint8_t chr
 )
 {
 	if (chr == '\f') {		/* Clear Screen and Return Home */
 		lcd_write(0, 0x01);
 		DELAY_US(LCD_DT1);
 		lcd_locate(0, 0);
 		return;
 	}

 	if (Row >= _LCD_ROWS) return;

 	if (chr == '\r') {	/* Cursor return */
 		lcd_locate(Row, 0);
 		return;
 	}
 	if (chr == '\n') {	/* Next row */
 		lcd_locate(Row + 1, 0);
 		return;
 	}
 	if (chr == '\b') {	/* Cursor back */
 		if (Column)
 			lcd_locate(Row, Column - 1);
 		return;
 	}

 	if (Column >= _LCD_COLS) return;

 	lcd_write((LCD_IF_DUAL && Row >= 2) ? 3 : 5, chr);
 	Column++;

 	if (LCD_IF_SPLIT && Column == _LCD_COLS / 2)
 		lcd_write(0, 0x40);

 	if (Column >= _LCD_COLS)
 		lcd_locate(Row + 1, 0);
 }


 /*-----------------------------------------------------------------------*/
 /* Set cursor form                                                       */
 /*-----------------------------------------------------------------------*/

 #if _USE_CURSOR
 void lcd_cursor (
 	uint8_t stat	/* 0:off, 1:blinking block, 2:under-line */
 )
 {
 	Csr = stat & 3;
 	lcd_locate(Row, Column);
 }
 #endif


 /*-----------------------------------------------------------------------*/
 /* Register user character pattern                                       */
 /*-----------------------------------------------------------------------*/

 #if _USE_CGRAM
 void lcd_setcg (
 	uint8_t chr,		/* Character code to be registered (0..7) */
 	uint8_t n,			/* Number of characters to register */
 	const uint8_t* p	/* Pointer to the character pattern (8 * n bytes) */
 )
 {
 	lcd_write(0, 0x40 | chr * 8);
 	n *= 8;
 	do
 		lcd_write(1, *p++);
 	while (--n);

 	lcd_locate(Row, Column);
 }
 #endif


 /*-----------------------------------------------------------------------*/
 /* Put a fuel indicator                                                  */
 /*-----------------------------------------------------------------------*/

 #if _USE_FUEL && _USE_CGRAM
 void lcd_put_fuel (
 	int8_t val,		/* Fuel level (-1:plugged, 0:empty cell, ..., 5:full cell) */
 	uint8_t chr		/* User character to use */
 )
 {
 	static const uint8_t plg[8] = {10,10,31,31,14,4,7,0};
 	uint8_t gfx[8], d, *p;
 	int8_t i;


 	if (val >= 0) {		/* Cell (0..5) */
 		p = &gfx[8];
 		*(--p) = 0; *(--p) = 0x1F;
 		for (i = 1; i <= 5; i++) {
 			d = 0x1F;
 			if (val < i) d = (i == 5) ? 0x1B : 0x11;
 			*(--p) = d;
 		}
 		*(--p) = 0x0E;
 	} else {			/* Plug (-1) */
 		p = (uint8_t*)plg;
 	}
 	lcd_setcg(chr, 1, p);
 	lcd_putc(chr);
 }


 #endif


 /*-----------------------------------------------------------------------*/
 /* Draw bargraph                                                         */
 /*-----------------------------------------------------------------------*/

 #if _USE_BAR && _USE_CGRAM
 void lcd_put_bar (
 	uint16_t val,	/* Bar length (0 to _MAX_BAR represents bar length from left end) */
 	uint8_t width,	/* Display area (number of chars from cursor position) */
 	uint8_t chr		/* User character code (2 chars used from this) */
 )
 {
 	static const uint8_t ptn[] = {
 		0xE0, 0xE0, 0xE0, 0xC0, 0xC0, 0xC0, 0x80, 0,
 		0xF0, 0xE0, 0xE0, 0xE0, 0xC0, 0xC0, 0xC0, 0,
 		0xF0, 0xF0, 0xE0, 0xE0, 0xE0, 0xC0, 0xC0, 0
 	};
 	const uint8_t *pp;
 	uint16_t n, m, s, gi;
 	uint8_t gfx[16];


 	for (n = 0; n < 16; n++)		/* Register common pattern (space/fill) */
 		gfx[n] = n < 7 ? 0 : 0xFF;
 	lcd_setcg(_BASE_GRAPH, 2, gfx);

 	/* Draw edge pattern into gfx[] */
 	val = (unsigned long)val * (width * 18) / (_MAX_BAR + 1);
 	pp = &ptn[(val % 3) * 8];		/* Get edge pattern */
 	s = val / 3 % 6;				/* Bit shift */
 	for (n = 0; n < 7; n++) {		/* Draw edge pattern into the pattern buffer */
 		m = (*pp++ | 0xFF00) >> s;
 		gfx[n] = m;
 		gfx[n + 8] = m >> 6;
 	}

 	/* Put graphic pattern into the LCD module */
 	gi = val / 18;						/* Indicator start position */
 	for (n = 1; n <= width; n++) {		/* Draw each location in the bargraph */
 		if (n == gi) {					/* When edge pattern is exist at the location */
 			m = chr + 1;				/* A edge pattern */
 		} else {
 			if (n == gi + 1) {
 				lcd_setcg(chr, 2, gfx);	/* Register edge pattern */
 				m = chr;
 			} else {
 				m = (n >= gi) ? _BASE_GRAPH : _BASE_GRAPH + 1;	/* A space or fill */
 			}
 		}
 		lcd_putc(m);					/* Put the character into the LCD */
 	}
 }
 #endif


 /*-----------------------------------------------------------------------*/
 /* Draw point indicator                                                  */
 /*-----------------------------------------------------------------------*/

 #if _USE_POINT && _USE_CGRAM
 void lcd_put_point (
 	uint16_t val,	/* Dot position (0 to _MAX_POINT represents left end to write end) */
 	uint8_t width,	/* Display area (number of chars from cursor position) */
 	uint8_t chr		/* User character code (2 chars used from this) */
 )
 {
 	static const uint8_t ptn[] = {
 		0x06, 0x0C, 0x0C, 0x0C, 0x18, 0x18, 0x18, 0,
 		0x06, 0x06, 0x0C, 0x0C, 0x0C, 0x18, 0x18, 0,
 		0x06, 0x06, 0x06, 0x0C, 0x0C, 0x0C, 0x18, 0
 	};
 	const uint8_t *pp;
 	uint16_t n, m, s, gi;
 	uint8_t gfx[16];


 	for (n = 0; n < 16; n++)		/* Register common pattern (space) */
 		gfx[n] = n < 7 ? 0 : 0xFF;
 	lcd_setcg(_BASE_GRAPH, 1, gfx);

 	/* Draw edge pattern into gfx[] */
 	val = (uint32_t)val * (width * 18 - 12) / (_MAX_BAR + 1);
 	pp = &ptn[(val % 3) * 8];		/* Get edge pattern */
 	s = val / 3 % 6;				/* Bit shift */
 	for (n = 0; n < 7; n++) {		/* Draw edge pattern into the pattern buffer */
 		m = *pp++; m <<= 6; m >>= s;
 		gfx[n] = m;
 		gfx[n + 8] = m >> 6;
 	}
 	lcd_setcg(chr, 2, gfx);				/* Register dot pattern */

 	/* Put graphic pattern into the LCD module */
 	gi = val / 18;						/* Indicator start position */
 	for (n = 0; n < width; n++) {		/* Draw each location in the bargraph */
 		if (n == gi) {					/* When edge pattern is exist at the location */
 			m = chr + 1;				/* A edge pattern */
 		} else {
 			if (n == gi + 1)
 				m = chr;
 			else
 				m = _BASE_GRAPH;		/* A space */
 		}
 		lcd_putc(m);					/* Put the character into the LCD */
 	}
 }
 #endif
	/*------------------------------------------------------------------------/
	/ EZ-LCD - Generic control module for HD44780 LCDC - R0.01c
	/-------------------------------------------------------------------------/
	/
	/ Copyright (C) 2010, ChaN, all right reserved.
	/
	/ * This software is a free software and there is NO WARRANTY.
	/ * No restriction on use. You can use, modify and redistribute it for
	/ personal, non-profit or commercial products UNDER YOUR RESPONSIBILITY.
	/ * Redistributions of source code must retain the above copyright notice.
	/
	/-------------------------------------------------------------------------/
	/ Nov 12,'10 R0.01c First release.
	/------------------------------------------------------------------------*/
	#include <machine.h>
	#include "hd44780.h"

	/-------------------------------------------------------------------------/
	/* Platform dependent macros and functions needed to be modified */
	/-------------------------------------------------------------------------/

	/* Bus controls */
	#include "iodefine.h" /* Device specific include file */
	#include "rskrx210def.h"

	#define IF_BUS 4 /* Data bus width (4 or 8) */
	#define IF_INIT() {} /* Initialize control port */
	#define E1_HIGH() LCD_EN = 1 /* Set E(E1) high */
	#define E1_LOW() LCD_EN = 0 /* Set E(E1) low */
	#define E2_HIGH() /* Set E2 high (dual controller only) */
	#define E2_LOW() /* Set E2 low (dual controller only) */
	#define RS_HIGH() LCD_RS = 1 /* Set RS high */
	#define RS_LOW() LCD_RS = 0 /* Set RS low */
	#define OUT_DATA(d) LCD_DATA = (d & 0x0F)//LCD_DATA = ((LCD_DATA & 0xF0) \| (d & 0x0F)) /* Output a byte d on the data bus (higher 4 bits of d in 4-bit mode) */
	#define IF_DLY60() {nop();nop();nop(); } /* Delay >=60ns (can be blanked for most uC) */
	#define IF_DLY450() {unsigned long x; for(x=0; x<22; x++){nop();}} /* Delay >=450ns@3V, >=250ns@5V */
	#define DELAY_US(n) {unsigned long x; for(x=0; x<(n50); x++){nop();}} / Delay n microseconds */

	/* Characteristics of LCD module */
	#define LCD_ETIME_1 1530 /* Execution time of Clear Display command [us] */
	#define LCD_ETIME_2 43 /* Execution time of other command and data write [us] */
	#define LCD_DLF 2.0 /* Delay factor (>=2.0) */



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


	#if _LCD_ROWS >= 2 \|\| _LCD_COLS > 8
	#define LCD_IF_2ROW 8 /* 2-row cfg. */
	#if _LCD_ROWS == 1
	#define LCD_IF_SPLIT 1 /* Half split row */
	#else
	#define LCD_IF_SPLIT 0 /* Direct row */
	#endif
	#else
	#define LCD_IF_2ROW 0 /* 1-row cfg. */
	#endif

	#if _LCD_ROWS == 4 && _LCD_COLS <= 20
	#define LCD_IF_ALTROW 1 /* Alternate row layout */
	#else
	#define LCD_IF_ALTROW 0 /* Incremental row layout */
	#endif

	#if _LCD_ROWS == 4 && _LCD_COLS > 20
	#define LCD_IF_DUAL 1 /* Dual controller */
	#else
	#define LCD_IF_DUAL 0 /* Single controller */
	#endif

	#define LCD_DT1 ((uint16_t)(LCD_ETIME_1 * LCD_DLF))
	#define LCD_DT2 ((uint16_t)(LCD_ETIME_2 * LCD_DLF))



	static
	uint8_t Row, Column; /* Current cursor position */
	#if _USE_CURSOR
	static
	uint8_t Csr; /* Current cursor state */
	#endif




	/----------------------------------------------/
	/* Write a byte to the LCD controller */
	/----------------------------------------------/

	static
	void lcd_write (
	uint8_t reg, /* b0:command(0)/data(1), b2..1:E1(2)/E2(1)/both(0)(don't care on single controller), b3:write high nibble only(don't care on 8-bit bus) */
	uint8_t dat /* Byte to be written */
	)
	{
	if (reg & 1) /* Select register */
	RS_HIGH();
	else
	RS_LOW();
	IF_DLY60();

	#if IF_BUS == 4
	if (!(reg & 8)) {
	OUT_DATA(dat);
	#if LCD_IF_DUAL
	if (!(reg & 2)) E1_HIGH();
	if (!(reg & 4)) E2_HIGH();
	IF_DLY450();
	E1_LOW();
	E2_LOW();
	#else
	E1_HIGH();
	IF_DLY450();
	E1_LOW();
	#endif
	IF_DLY450();
	dat <<= 4;
	}
	#endif

	OUT_DATA(dat);
	#if LCD_IF_DUAL
	if (!(reg & 2)) E1_HIGH();
	if (!(reg & 4)) E2_HIGH();
	IF_DLY450();
	E1_LOW();
	E2_LOW();
	#else
	E1_HIGH();
	IF_DLY450();
	E1_LOW();
	#endif

	DELAY_US(LCD_DT2); /* Always use timer */
	}



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

	void lcd_init (void)
	{
	uint8_t d;

	E1_HIGH();
	DELAY_US(40000);
	E1_LOW();

	// IF_INIT();

	// DELAY_US(40000);
	lcd_write(8, 0x30);
	DELAY_US(4100);
	lcd_write(8, 0x30);
	DELAY_US(100);
	lcd_write(8, 0x30);

	d = (IF_BUS == 4 ? 0x20 : 0x30) \| LCD_IF_2ROW;
	lcd_write(8, d);
	#if IF_BUS == 4
	lcd_write(0, d);
	#endif
	lcd_write(0, 0x08);
	lcd_write(0, 0x01);
	DELAY_US(LCD_DT1);
	lcd_write(0, 0x06);
	lcd_write(0, 0x0C);

	Row = Column = 0;
	#if _USE_CURSOR
	Csr = 0;
	#endif
	}



	/-----------------------------------------------------------------------/
	/* Set cursor position */
	/-----------------------------------------------------------------------/

	void lcd_locate (
	uint8_t row, /* Cursor row position (0.._LCD_ROWS-1) */
	uint8_t col /* Cursor column position (0.._LCD_COLS-1) */
	)
	{
	Row = row; Column = col;

	if (row < _LCD_ROWS && col < _LCD_COLS) {
	if (_LCD_COLS >= 2 && (row & 1)) col += 0x40;
	if (LCD_IF_SPLIT && col >= _LCD_COLS / 2) col += 0x40 - _LCD_COLS / 2;
	if (LCD_IF_ALTROW && (row & 2)) col += _LCD_COLS;
	col \|= 0x80;
	} else {
	col = 0x0C;
	}

	#if LCD_IF_DUAL
	if (_USE_CURSOR && !(row &= 2)) row \|= 4;
	lcd_write(row, col);
	#if _USE_CURSOR
	if (col != 0x0C) lcd_write(row, Csr \| 0x0C);
	row ^= 6;
	lcd_write(row, 0x0C);
	#endif
	#else
	lcd_write(0, col);
	#if _USE_CURSOR
	if (col != 0x0C) lcd_write(0, Csr \| 0x0C);
	#endif
	#endif
	}



	/-----------------------------------------------------------------------/
	/* Put a character */
	/-----------------------------------------------------------------------/

	void lcd_putc (
	uint8_t chr
	)
	{
	if (chr == '\f') { /* Clear Screen and Return Home */
	lcd_write(0, 0x01);
	DELAY_US(LCD_DT1);
	lcd_locate(0, 0);
	return;
	}

	if (Row >= _LCD_ROWS) return;

	if (chr == '\r') { /* Cursor return */
	lcd_locate(Row, 0);
	return;
	}
	if (chr == '\n') { /* Next row */
	lcd_locate(Row + 1, 0);
	return;
	}
	if (chr == '\b') { /* Cursor back */
	if (Column)
	lcd_locate(Row, Column - 1);
	return;
	}

	if (Column >= _LCD_COLS) return;

	lcd_write((LCD_IF_DUAL && Row >= 2) ? 3 : 5, chr);
	Column++;

	if (LCD_IF_SPLIT && Column == _LCD_COLS / 2)
	lcd_write(0, 0x40);

	if (Column >= _LCD_COLS)
	lcd_locate(Row + 1, 0);
	}



	/-----------------------------------------------------------------------/
	/* Set cursor form */
	/-----------------------------------------------------------------------/

	#if _USE_CURSOR
	void lcd_cursor (
	uint8_t stat /* 0:off, 1:blinking block, 2:under-line */
	)
	{
	Csr = stat & 3;
	lcd_locate(Row, Column);
	}
	#endif



	/-----------------------------------------------------------------------/
	/* Register user character pattern */
	/-----------------------------------------------------------------------/

	#if _USE_CGRAM
	void lcd_setcg (
	uint8_t chr, /* Character code to be registered (0..7) */
	uint8_t n, /* Number of characters to register */
	const uint8_t* p /* Pointer to the character pattern (8 * n bytes) */
	)
	{
	lcd_write(0, 0x40 \| chr * 8);
	n *= 8;
	do
	lcd_write(1, *p++);
	while (--n);

	lcd_locate(Row, Column);
	}
	#endif



	/-----------------------------------------------------------------------/
	/* Put a fuel indicator */
	/-----------------------------------------------------------------------/

	#if _USE_FUEL && _USE_CGRAM
	void lcd_put_fuel (
	int8_t val, /* Fuel level (-1:plugged, 0:empty cell, ..., 5:full cell) */
	uint8_t chr /* User character to use */
	)
	{
	static const uint8_t plg[8] = {10,10,31,31,14,4,7,0};
	uint8_t gfx[8], d, *p;
	int8_t i;


	if (val >= 0) { /* Cell (0..5) */
	p = &gfx[8];
	(--p) = 0; (--p) = 0x1F;
	for (i = 1; i <= 5; i++) {
	d = 0x1F;
	if (val < i) d = (i == 5) ? 0x1B : 0x11;
	*(--p) = d;
	}
	*(--p) = 0x0E;
	} else { /* Plug (-1) */
	p = (uint8_t*)plg;
	}
	lcd_setcg(chr, 1, p);
	lcd_putc(chr);
	}


	#endif



	/-----------------------------------------------------------------------/
	/* Draw bargraph */
	/-----------------------------------------------------------------------/

	#if _USE_BAR && _USE_CGRAM
	void lcd_put_bar (
	uint16_t val, /* Bar length (0 to _MAX_BAR represents bar length from left end) */
	uint8_t width, /* Display area (number of chars from cursor position) */
	uint8_t chr /* User character code (2 chars used from this) */
	)
	{
	static const uint8_t ptn[] = {
	0xE0, 0xE0, 0xE0, 0xC0, 0xC0, 0xC0, 0x80, 0,
	0xF0, 0xE0, 0xE0, 0xE0, 0xC0, 0xC0, 0xC0, 0,
	0xF0, 0xF0, 0xE0, 0xE0, 0xE0, 0xC0, 0xC0, 0
	};
	const uint8_t *pp;
	uint16_t n, m, s, gi;
	uint8_t gfx[16];


	for (n = 0; n < 16; n++) /* Register common pattern (space/fill) */
	gfx[n] = n < 7 ? 0 : 0xFF;
	lcd_setcg(_BASE_GRAPH, 2, gfx);

	/* Draw edge pattern into gfx[] */
	val = (unsigned long)val * (width * 18) / (_MAX_BAR + 1);
	pp = &ptn[(val % 3) * 8]; /* Get edge pattern */
	s = val / 3 % 6; /* Bit shift */
	for (n = 0; n < 7; n++) { /* Draw edge pattern into the pattern buffer */
	m = (*pp++ \| 0xFF00) >> s;
	gfx[n] = m;
	gfx[n + 8] = m >> 6;
	}

	/* Put graphic pattern into the LCD module */
	gi = val / 18; /* Indicator start position */
	for (n = 1; n <= width; n++) { /* Draw each location in the bargraph */
	if (n == gi) { /* When edge pattern is exist at the location */
	m = chr + 1; /* A edge pattern */
	} else {
	if (n == gi + 1) {
	lcd_setcg(chr, 2, gfx); /* Register edge pattern */
	m = chr;
	} else {
	m = (n >= gi) ? _BASE_GRAPH : _BASE_GRAPH + 1; /* A space or fill */
	}
	}
	lcd_putc(m); /* Put the character into the LCD */
	}
	}
	#endif



	/-----------------------------------------------------------------------/
	/* Draw point indicator */
	/-----------------------------------------------------------------------/

	#if _USE_POINT && _USE_CGRAM
	void lcd_put_point (
	uint16_t val, /* Dot position (0 to _MAX_POINT represents left end to write end) */
	uint8_t width, /* Display area (number of chars from cursor position) */
	uint8_t chr /* User character code (2 chars used from this) */
	)
	{
	static const uint8_t ptn[] = {
	0x06, 0x0C, 0x0C, 0x0C, 0x18, 0x18, 0x18, 0,
	0x06, 0x06, 0x0C, 0x0C, 0x0C, 0x18, 0x18, 0,
	0x06, 0x06, 0x06, 0x0C, 0x0C, 0x0C, 0x18, 0
	};
	const uint8_t *pp;
	uint16_t n, m, s, gi;
	uint8_t gfx[16];


	for (n = 0; n < 16; n++) /* Register common pattern (space) */
	gfx[n] = n < 7 ? 0 : 0xFF;
	lcd_setcg(_BASE_GRAPH, 1, gfx);

	/* Draw edge pattern into gfx[] */
	val = (uint32_t)val * (width * 18 - 12) / (_MAX_BAR + 1);
	pp = &ptn[(val % 3) * 8]; /* Get edge pattern */
	s = val / 3 % 6; /* Bit shift */
	for (n = 0; n < 7; n++) { /* Draw edge pattern into the pattern buffer */
	m = *pp++; m <<= 6; m >>= s;
	gfx[n] = m;
	gfx[n + 8] = m >> 6;
	}
	lcd_setcg(chr, 2, gfx); /* Register dot pattern */

	/* Put graphic pattern into the LCD module */
	gi = val / 18; /* Indicator start position */
	for (n = 0; n < width; n++) { /* Draw each location in the bargraph */
	if (n == gi) { /* When edge pattern is exist at the location */
	m = chr + 1; /* A edge pattern */
	} else {
	if (n == gi + 1)
	m = chr;
	else
	m = _BASE_GRAPH; /* A space */
	}
	lcd_putc(m); /* Put the character into the LCD */
	}
	}
	#endif