lcd.c

/*
    lcd - LCD routines
    Copyright (C) 2011 Pavel Semerad

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/



/* LCD controler is HOLTEK HT1621B */

#include <string.h>
#include "lcd.h"


// HT1621B modes
#define HT_COMMAND	0b100
// 6 address bits (but only 5 used in this chip) and 4 bits of data
#define HT_WRITE	0b101
#define HT_READ		0b110

// HT1621B commands, 9bits, but last bit is used in no command
#define HT_SYS_DIS	0b00000000
#define HT_SYS_EN	0b00000001
#define HT_LCD_OFF	0b00000010
#define HT_LCD_ON	0b00000011
#define HT_TIMER_DIS	0b00000100
#define HT_WDT_DIS	0b00000101
#define HT_TIMER_EN	0b00000110
#define HT_WDT_EN	0b00000111
#define HT_TONE_OFF	0b00001000
#define HT_TONE_ON	0b00001001
#define HT_CLR_TIMER	0b00001100
#define HT_CLR_WDT	0b00001110
#define HT_XTAL_32K	0b00010100
#define HT_RC_256K	0b00011000
#define HT_EX_256K	0b00011100
#define HT_BIAS_12	0b00100000
#define HT_BIAS_13	0b00100001
    #define HT_BIAS_SHIFT 2
#define HT_TONE_4K	0b01000000
#define HT_TONE_2K	0b01100000
#define HT_IRQ_DIS	0b10000000
#define HT_IRQ_EN	0b10001000
#define HT_F1		0b10100000
#define HT_F2		0b10100001
#define HT_F4		0b10100010
#define HT_F8		0b10100011
#define HT_F16		0b10100100
#define HT_F32		0b10100101
#define HT_F64		0b10100110
#define HT_F128		0b10100111
#define HT_TEST		0b11100000
#define HT_NORMAL	0b11100011


// microcontroller pins setting
#define CS0 BRES(PC_ODR, 3)
#define CS1 BSET(PC_ODR, 3)
#define WR0 BRES(PF_ODR, 4)
#define WR1 BSET(PF_ODR, 4)
#define DATA0 BRES(PE_ODR, 5)
#define DATA1 BSET(PE_ODR, 5)





/* low level LCD routines and initialization */

// send cnt bits to LCD controller, only low bits of "bits" are used
// use timer4 to get 600kHz clock for driving WR/ signal
// timer is used in one-pulse mode and is started after each WR/ change,
//   so there will always be minimal required length of pulse also
//   when interrupted by some interrupt
static void lcd_send_bits(u8 cnt, u16 bits) {
    // shift bits to high-bits
    bits <<= (u8)(16 - cnt);
    WR0;
    BSET(TIM4_CR1, 0);			// start timer
    WR0;				// optimize hack
    do {
	if (bits & 0x8000) {
	    DATA1;
	}
	else {
	    DATA0;
	}
	bits <<= 1;			// to next bit
	while (!BCHK(TIM4_SR, 0));	// wait for timer
	WR1;
	BRES(TIM4_SR, 0);		// clear intr flag
	BSET(TIM4_CR1, 0);		// start timer
	if (!--cnt)  break;
	while (!BCHK(TIM4_SR, 0));	// wait for timer
	WR0;
	BRES(TIM4_SR, 0);		// clear intr flag
	BSET(TIM4_CR1, 0);		// start timer
    } while (1);
    while (!BCHK(TIM4_SR, 0));		// wait for timer
    BRES(TIM4_SR, 0);			// clear intr flag
}


// send command to LCD
static void lcd_command(u8 cmd) {
    CS0;
    lcd_send_bits(12, (HT_COMMAND << 9) | (cmd << 1));
    CS1;
}


// LCD task and main loop
TASK(LCD, 40);
static void lcd_loop(void);

// initialize LCD pins and LCD controller
void lcd_init(void) {
    // set direction of pins
    IO_OPF(C, 3);  // CS/ pin
    IO_OP(E, 5);   // DATA pin
    IO_OP(F, 4);   // WR/ pin
    IO_OP(D, 2);   // Backlight pin

    // set default values to pins
    CS1;
    WR1;
    DATA1;
    LCD_BCK0;

    // initialize timer 4 used to time WR/ signal
    BSET(CLK_PCKENR1, 4);     // enable clock to TIM4
    TIM4_CR1 = 0b00001100;    // no auto-reload, one-pulse,URS-overflow, disable
    TIM4_IER = 0;             // no interrupts
    TIM4_PSCR = 0;            // prescaler = 1
    TIM4_ARR = 24;            // it will be about 600kHz for WR/ signal
    TIM4_CNTR = 0;	      // reset timer value

    // initialize HT1621B
    lcd_command(HT_BIAS_13 | (0b10 << HT_BIAS_SHIFT));  // BIAS 1/3, 4 COMs
    lcd_command(HT_RC_256K);  // clock RC 256kHz
    lcd_command(HT_SYS_DIS);  // OSC+BIAS off
    lcd_command(HT_WDT_DIS);  // disable WDT
    lcd_command(HT_SYS_EN);   // OSC on
    lcd_command(HT_LCD_ON);   // BIAS on

    // initialize LCD task, will be used when sending following lcd_command-s
    build(LCD);
    activate(LCD, lcd_loop);
    sleep(LCD);		      // no work yet
}






/* actual LCD controller segment memory and updating routine */

#define MAX_SEGMENT 32
static u8 lcd_segments[MAX_SEGMENT];
// bit flags of segments, which were modified from last update
static volatile u16 lcd_modified_segments;
static volatile u16 lcd_modified_segments2;


// set LCD segment to given comms, remember modified only when different
// will be sent to LCD controller after update
static void lcd_seg_comms(u8 segment, u8 comms) {
    u8 *seg = &lcd_segments[segment];
    if (*seg == comms)  return;		// no change
    *seg = comms;
    if (segment < 16) {
	lcd_modified_segments |= (u16)1 << segment;
    }
    else {
	lcd_modified_segments2 |= (u16)1 << (u8)(segment - 16);
    }
}


// send changed LCD segments to LCD controller
static void lcd_seg_update(void) {
    u8 i;
    u16 bit;
    for (i = 0; i < MAX_SEGMENT; i++) {
	if (i < 16) {
	    bit = (u16)1 << i;
	    if (!(lcd_modified_segments & bit))  continue;
	}
	else {
	    bit = (u16)1 << (u8)(i - 16);
	    if (!(lcd_modified_segments2 & bit))  continue;
	}
	CS0;
	lcd_send_bits(13, (HT_WRITE << 10) | (i << 4) | lcd_segments[i]);
	CS1;
    }
    lcd_modified_segments = lcd_modified_segments2 = 0;
}





/* routines for manipulating each segment individually and for blinking */

// flags used for communicating between tasks to activate LCD update
static volatile _Bool lcd_update_flag;
static volatile _Bool lcd_clr_flag;
static volatile _Bool lcd_set_flag;

// low 4 bits contains actual segment values
// high 8 bits contains segments, which will be blinking
static u8 lcd_bitmap[MAX_SEGMENT];
volatile _Bool lcd_blink_flag;		// set in timer interrupt in blink times
volatile u8 lcd_blink_cnt;		// blink counter updated in timer
volatile _Bool lcd_blink_something;  // there are some blink segments



// set LCD segment "pos" ON or OFF
// pos contains SEGMENT address in bits 0-4 and COM number in bits 7-8
// sets bit in array lcs_segments only and sets flag that this segment was
//   changed (segment can be changed more times and we will send it to
//   LCD controller only once)
void lcd_segment(u8 pos, u8 on_off) {
    u8 segment = (u8)(pos & 0b00011111);
    u8 com_bit = (u8)(1 << (u8)((pos & 0b11000000) >> 6));
    if (on_off) {
	lcd_bitmap[segment] |= com_bit;
    }
    else {
	lcd_bitmap[segment] &= (u8)~com_bit;
    }
    // turn blinking off for this bit
    lcd_bitmap[segment] &= (u8)~(com_bit << 4);
}


// set blinking state for given segment
// 0 - off
// 1 - on only when corresponding LCD segment is on
// 2 - on always
void lcd_segment_blink(u8 pos, u8 on_off) {
    u8 segment = (u8)(pos & 0b00011111);
    u8 com_bit = (u8)(1 << (u8)((pos & 0b11000000) >> 6));
    u8 blnk_bit = (u8)(com_bit << 4);
    if (on_off && !(on_off == LB_SPC && !(lcd_bitmap[segment] & com_bit))) {
	lcd_bitmap[segment] |= blnk_bit;
	// start blinking, also reset counter to 0
	if (!lcd_blink_something) {
	    lcd_blink_cnt = 0;
	    lcd_blink_flag = 0;
	    lcd_blink_something = 1;
	}
    }
    else {
	lcd_bitmap[segment] &= (u8)~blnk_bit;
    }
}


// show normal (non-blinked) LCD bitmap
static void lcd_show_normal(void) {
    u8 i;
    for (i = 0; i < MAX_SEGMENT; i++) {
	lcd_seg_comms(i, (u8)(lcd_bitmap[i] & 0xf));
    }
    lcd_seg_update();
}


// show blinked LCD bitmap
static void lcd_show_inverted(u8 update) {
    u8 i, c;
    u8 inverted = 0;
    for (i = 0; i < MAX_SEGMENT; i++) {
	c = lcd_bitmap[i];
	if (!(c & 0xf0)) {
	    // nothing to invert, but if update, send non-inverted
	    if (update)
		lcd_seg_comms(i, (u8)(c & 0xf));
	    continue;
	}
	lcd_seg_comms(i, (u8)((u8)(c & 0xf) ^ (u8)((u8)(c & 0xf0) >> 4)));
	inverted = 1;
    }
    if (inverted)  lcd_seg_update();
    else {
	lcd_blink_something = 0;	// nothing was blinked
	if (update)  lcd_seg_update();	// but if update requested, do it
    }
}


// do LCD item blinking at regular timer times
static void lcd_blink(u8 update) {
    lcd_blink_flag = 0;
    if (update)  lcd_update_flag = 0;
    if (lcd_blink_cnt < LCD_BLNK_CNT_BLANK) {
	lcd_show_normal();
    }
    else {
	lcd_show_inverted(update);
    }
}






// full LCD clear or set all segments ON
// quicker way, doing continuous-write to LCD controller
// memory locations representing LCD states must be set accordingly
static void lcd_clr_set(u16 data) {
    u8 i;
    // clear flags
    lcd_clr_flag = 0;
    lcd_set_flag = 0;
    lcd_update_flag = 0;
    lcd_blink_flag = 0;
    lcd_blink_cnt = 0;		// reset blink counter
    // set memory locations
    memset(lcd_segments, (u8)(data & 0x0f), sizeof(lcd_segments));
    memset(lcd_bitmap, (u8)(data & 0x0f), sizeof(lcd_bitmap));
    lcd_modified_segments = 0;
    lcd_modified_segments2 = 0;
    lcd_blink_something = 0;
    CS0;
    // set lcd address to 0
    lcd_send_bits(9, HT_WRITE << 6);
    // send 32x 4bits of data in group of 16 bits
    for (i = 0; i < MAX_SEGMENT / 4; i++) {
	lcd_send_bits(16, data);
    }
    CS1;
}





// main LCD task, handle update/cle/set/blink requests
static void lcd_loop(void) {
    u8 i;
    while (1) {
	if (lcd_clr_flag)		lcd_clr_set(0);
	else if (lcd_set_flag)		lcd_clr_set(0xffff);
	else if (lcd_update_flag)	lcd_blink(1);
	else if (lcd_blink_flag)	lcd_blink(0);
	stop();
    }
}






// LCD segment addresses

// bits from left-top down, then next column, 0-terminated
const u8 lcd_seg_char1[] = {
    0x1d, 0x5d, 0x9d, 0x9a, 0x5a, 0x1a, 0xda,
    0x1e, 0x5e, 0x9e, 0x99, 0x59, 0x19, 0xd9,
    0x1f, 0x5f, 0x9f, 0x98, 0x58, 0x18, 0xd8,
    0x11, 0x51, 0x91, 0x97, 0x57, 0x17, 0xd7,
    0x10, 0x50, 0x90, 0x96, 0x56, 0x16, 0xd6,
    0
};
const u8 lcd_seg_char2[] = {
    0x0f, 0x4f, 0x8f, 0x95, 0x55, 0x15, 0xd5,
    0x0e, 0x4e, 0x8e, 0x94, 0x54, 0x14, 0xd4,
    0x0d, 0x4d, 0x8d, 0x93, 0x53, 0x13, 0xd3,
    0x0c, 0x4c, 0x8c, 0x92, 0x52, 0x12, 0xd2,
    0x0b, 0x4b, 0x8b, 0x80, 0x40, 0x20, 0xc0,  // 0x20 is using unuset bit to not have 0x00
    0
};
const u8 lcd_seg_char3[] = {
    0x0a, 0x4a, 0x8a, 0x81, 0x41, 0x01, 0xc1,
    0x09, 0x49, 0x89, 0x82, 0x42, 0x02, 0xc2,
    0x08, 0x48, 0x88, 0x83, 0x43, 0x03, 0xc3,
    0x07, 0x47, 0x87, 0x84, 0x44, 0x04, 0xc4,
    0x06, 0x46, 0x86, 0x85, 0x45, 0x05, 0xc5,
    0
};
const u8 lcd_seg_7seg[] = {
    0x9c, 0x1c, 0x9b, 0x5c, 0xdb, 0x5b, 0x1b,
    0
};
// first line, second line
const u8 lcd_seg_menu[] = {
    LS_MENU_MODEL, LS_MENU_NAME, LS_MENU_REV, LS_MENU_EPO,
    LS_MENU_TRIM,  LS_MENU_DR,   LS_MENU_EXP, LS_MENU_ABS,
    0
};

static const struct lcd_items_s {
    u8 *segments;	// address of lcd_seg_...
    u8 bits;		// number of bits used in each bitmap byte
} lcd_items[5] = {
    { lcd_seg_char1, 7 },
    { lcd_seg_char2, 7 },
    { lcd_seg_char3, 7 },
    { lcd_seg_7seg, 7 },
    { lcd_seg_menu, 8 }
};




// set LCD element id to given bitmap
void lcd_set(u8 id, u8 *bitmap) {
    struct lcd_items_s *li = &lcd_items[id];
    u8 *seg = li->segments;	// actual lcd segment pointer
    u8 sp = *seg++;		// actual lcd segment
    u8 bits = li->bits;		// number of bits in bitmap
    u8 bitpos = 8;		// bit position in bitmap byte
    u8 fake_bitmap = (u8)(bitmap >= (u8 *)0xff00);
    u8 bm;			// actual byte of bitmap
    if (fake_bitmap) {
	// special addresses are actually bitmap for all segments
	bm = (u8)((u16)bitmap & 0xff);
    }
    else {
	bm = *bitmap++;
    }
    do {
	// for seven-bits bitmaps, rotate first
	if (bitpos > bits) {
	    bm <<= 1;
	    bitpos -= 1;
	}
	// set segment
	lcd_segment(sp, (u8)(bm & 0x80 ? LS_ON : LS_OFF));
	if (!(sp = *seg++))  break; 
	// to next bitmap bit/byte
	if (--bitpos) {
	    // next bit
	    bm <<= 1;
	}
	else {
	    // next bitmap byte
	    bitpos = 8;
	    if (fake_bitmap) {
		bm = (u8)((u16)bitmap & 0xff);
	    }
	    else {
		bm = *bitmap++;
	    }
	}
    } while (1);
}


// set blink for LCD element id
void lcd_set_blink(u8 id, u8 on_off) {
    u8 *seg = lcd_items[id].segments;
    do {
	lcd_segment_blink(*seg, on_off);
    } while (*++seg);
}






// functions to write characters from character map to char id

// character map, columns from left to right, least significant bit down
static const u8 lcd_charmap[] = {
    0b0000000, 0b0000000, 0b0000000, 0b0000000, 0b0000000,	// space
    0b0000000, 0b0000000, 0b1111010, 0b0000000, 0b0000000,	// !
    0b0000000, 0b1110000, 0b0000000, 0b1110000, 0b0000000,	// "
    0b0010100, 0b1111111, 0b0010100, 0b1111111, 0b0010100,	// #
    0b0010010, 0b0101010, 0b1111111, 0b0101010, 0b0100100,	// $
    0b0010001, 0b0001001, 0b0000100, 0b0110010, 0b0110001,	// %
    0b0110110, 0b1001001, 0b1010101, 0b0100010, 0b0000101,	// &
    0b0000000, 0b1010000, 0b1100000, 0b0000000, 0b0000000,	// '
    0b0000000, 0b0011100, 0b0100010, 0b1000001, 0b0000000,	// (
    0b0000000, 0b1000001, 0b0100010, 0b0011100, 0b0000000,	// )
    0b0010100, 0b0001000, 0b0111110, 0b0001000, 0b0010100,	// *
    0b0001000, 0b0001000, 0b0111110, 0b0001000, 0b0001000,	// +
    0b0000000, 0b0000000, 0b0000101, 0b0000110, 0b0000000,	// ,
    0b0001000, 0b0001000, 0b0001000, 0b0001000, 0b0001000,	// -
    0b0000000, 0b0000011, 0b0000011, 0b0000000, 0b0000000,	// .
    0b0000010, 0b0000100, 0b0001000, 0b0010000, 0b0100000,	// /
    0b0111110, 0b1000101, 0b1001001, 0b1010001, 0b0111110,	// 0
    0b0000000, 0b0100001, 0b1111111, 0b0000001, 0b0000000,	// 1
    0b0100001, 0b1000011, 0b1000101, 0b1001001, 0b0110001,	// 2
    0b1000010, 0b1000001, 0b1010001, 0b1101001, 0b1000110,	// 3
    0b0001100, 0b0010100, 0b0100100, 0b1111111, 0b0000100,	// 4
    0b1110010, 0b1010001, 0b1010001, 0b1010001, 0b1001110,	// 5
    0b0011110, 0b0101001, 0b1001001, 0b1001001, 0b0000110,	// 6
    0b1000000, 0b1000111, 0b1001000, 0b1010000, 0b1100000,	// 7
    0b0110110, 0b1001001, 0b1001001, 0b1001001, 0b0110110,	// 8
    0b0110000, 0b1001001, 0b1001001, 0b1001010, 0b0111100,	// 9
    0b0000000, 0b0110110, 0b0110110, 0b0000000, 0b0000000,	// :
    0b0000000, 0b0110101, 0b0110110, 0b0000000, 0b0000000,	// ;
    0b0001000, 0b0010100, 0b0100010, 0b1000001, 0b0000000,	// <
    0b0010100, 0b0010100, 0b0010100, 0b0010100, 0b0010100,	// =
    0b0000000, 0b1000001, 0b0100010, 0b0010100, 0b0001000,	// >
    0b0100000, 0b1000000, 0b1000101, 0b1001000, 0b0110000,	// ?
    0b0100110, 0b1001001, 0b1001101, 0b1000101, 0b0111110,	// @
    0b0111111, 0b1000100, 0b1000100, 0b1000100, 0b0111111,	// A
    0b1111111, 0b1001001, 0b1001001, 0b1001001, 0b0110110,	// B
    0b0111110, 0b1000001, 0b1000001, 0b1000001, 0b0100010,	// C
    0b1111111, 0b1000001, 0b1000001, 0b0100010, 0b0011100,	// D
    0b1111111, 0b1001001, 0b1001001, 0b1001001, 0b1000001,	// E
    0b1111111, 0b1001000, 0b1001000, 0b1001000, 0b1000000,	// F
    0b0111110, 0b1000001, 0b1001001, 0b1001001, 0b0101111,	// G
    0b1111111, 0b0001000, 0b0001000, 0b0001000, 0b1111111,	// H
    0b0000000, 0b1000001, 0b1111111, 0b1000001, 0b0000000,	// I
    0b0000010, 0b0000001, 0b1000001, 0b1111110, 0b1000000,	// J
    0b1111111, 0b0001000, 0b0010100, 0b0100010, 0b1000001,	// K
    0b1111111, 0b0000001, 0b0000001, 0b0000001, 0b0000001,	// L
    0b1111111, 0b0100000, 0b0011000, 0b0100000, 0b1111111,	// M
    0b1111111, 0b0010000, 0b0001000, 0b0000100, 0b1111111,	// N
    0b0111110, 0b1000001, 0b1000001, 0b1000001, 0b0111110,	// O
    0b1111111, 0b1001000, 0b1001000, 0b1001000, 0b0110000,	// P
    0b0111110, 0b1000001, 0b1000101, 0b1000010, 0b0111101,	// Q
    0b1111111, 0b1001000, 0b1001100, 0b1001010, 0b0110001,	// R
    0b0110001, 0b1001001, 0b1001001, 0b1001001, 0b1000110,	// S
    0b1000000, 0b1000000, 0b1111111, 0b1000000, 0b1000000,	// T
    0b1111110, 0b0000001, 0b0000001, 0b0000001, 0b1111110,	// U
    0b1111100, 0b0000010, 0b0000001, 0b0000010, 0b1111100,	// V
    0b1111110, 0b0000001, 0b0001110, 0b0000001, 0b1111110,	// W
    0b1100011, 0b0010100, 0b0001000, 0b0010100, 0b1100011,	// X
    0b1110000, 0b0001000, 0b0000111, 0b0001000, 0b1110000,	// Y
    0b1000011, 0b1000101, 0b1001001, 0b1010001, 0b1100001,	// Z
    0b0001000, 0b0001000, 0b0100001, 0b1111111, 0b0000001,	// -1
    0b1111111, 0b0000000, 0b0111110, 0b1000001, 0b0111110,	// 10
};

// 7seg map, numbers 0-9,a-f(10-15)
// columns from left to right and top to down
static const u8 lcd_7segmap[] = {
    0b1110111,	// 0
    0b0000011,	// 1
    0b0111110,	// 2
    0b0011111,	// 3
    0b1001011,	// 4
    0b1011101,	// 5
    0b1111101,	// 6
    0b0010011,	// 7
    0b1111111,	// 8
    0b1011111,	// 9
    0b1111011,	// A
    0b1101101,	// b
    0b1110100,	// C
    0b0101111,	// d
    0b1111100,	// E
    0b1111000,	// F
    0b1110101,	// G
    0b1101011,	// H
    0b0000001,	// i
    0b0100111,	// J
    0b1101100,	// k
    0b1100100,	// L
    0b1110011,	// M
    0b0101001,	// n
    0b0101101,	// o
    0b1111010,	// P
    0b0101000,	// r
    0b1110000,	// T
    0b1100111,	// U
    0b0100101,	// v
    0b1101010,	// y
    0b0001000	// minus
};


// write char to LCD item id (LCHR1..3)
void lcd_char(u8 id, u8 c) {
    if (c < LCHAR_MIN || c > LCHAR_MAX)  c = '?';
    lcd_set(id, lcd_charmap + (c - LCHAR_MIN) * LCD_CHAR_COLS);
}


// write 3 chars
void lcd_chars(u8 *chars) {
    lcd_char(LCHR1, *chars++);
    lcd_char(LCHR2, *chars++);
    if (*chars)  lcd_char(LCHR3, *chars);  // to allow 2 char strings
}


// write 2 chars to chars 2+3
void lcd_chars2(u8 *chars) {
    lcd_char(LCHR2, *chars++);
    lcd_char(LCHR3, *chars++);
}


// common conversion to 2 chars
static u8 chr[3];  // results of number->string conversions
static void lcd_num2char(u8 num) {
    chr[1] = (u8)('0' + num / 10);
    chr[2] = (u8)('0' + num % 10);
}


// write unsigned number to 3 chars, max -199...1099
void lcd_char_num3(s16 num) {
    // check signum
    u8 sig = ' ';
    if (num < 0) {
	sig = '-';
	num = -num;
    }
    chr[0] = (u8)('0' + num / 100);
    lcd_num2char((u8)(num % 100));
    // if more than 999, go to special char 10
    if (chr[0] > '9')  chr[0] = LCHAR_ONE_ZERO;
    // remove leading spaces and add signum
    if (chr[0] == '0') {
	chr[0] = sig;
	if (chr[1] == '0') {
	    chr[1] = sig;
	    chr[0] = ' ';
	}
    }
    else if (sig == '-')  chr[0] = LCHAR_MINUS_ONE;
    lcd_chars(chr);
}


// write signed number, use labels for <0, =0, >0 (eg. "LNR")
void lcd_char_num2_lbl(s8 num, u8 *labels) {
    // set label based on signum
    if (num == 0)  chr[0] = labels[1];
    else if (num > 0)  chr[0] = labels[2];
    else {
	num = (u8)-num;
	chr[0] = labels[0];
    }
    lcd_num2char(num);
    lcd_chars(chr);
}


// write given number to 7-segment display
void lcd_7seg(u8 number) {
    lcd_set(L7SEG, lcd_7segmap + number);
}


// select menu-s
void lcd_menu(u8 menus) {
    lcd_set(LMENU, (u8 *)(menus | 0xff00));
}

// lcd_set_blink() for 3 chars
void lcd_chars_blink(u8 on_off) {
    lcd_set_blink(LCHR1, on_off);
    lcd_set_blink(LCHR2, on_off);
    lcd_set_blink(LCHR3, on_off);
}


// lcd_set_blink() for 3 chars masked by bits
void lcd_chars_blink_mask(u8 on_off, u8 mask) {
    if (mask & LB_CHR1)  lcd_set_blink(LCHR1, on_off);
    if (mask & LB_CHR2)  lcd_set_blink(LCHR2, on_off);
    if (mask & LB_CHR3)  lcd_set_blink(LCHR3, on_off);
}





// update/clear/set LCD display

// send modified data to LCD controller
void lcd_update(void) {
    lcd_update_flag = 1;
    awake(LCD);
}


// clear entire LCD
void lcd_clear(void) {
    lcd_clr_flag = 1;
    awake(LCD);
    pause();
}


// set all LCD segments ON
void lcd_set_full_on(void) {
    lcd_set_flag = 1;
    awake(LCD);
    pause();
}





// backlight handling

_Bool lcd_bck_on;		// set when backlight ON
u16   lcd_bck_count;		// counter in seconds
u16   lcd_bck_seconds;		// default number of backlight seconds


// set default ON seconds
void backlight_set_default(u16 seconds) {
    lcd_bck_seconds = seconds;
}


// set ON for given seconds
void backlight_on_sec(u16 seconds) {
    LCD_BCK1;
    lcd_bck_count = seconds;
    lcd_bck_on = 1;
}


// set on for default seconds
void backlight_on(void) {
    if (!lcd_bck_seconds)  return;	// nothing when not set
    backlight_on_sec(lcd_bck_seconds);
}


// set OFF
void backlight_off(void) {
    LCD_BCK0;
    lcd_bck_on = 0;
}