mangavalk/lcdproc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e481f1311ef00a0960a94cab1bcbbe2efc240629
lcdproc/server/drivers/hd44780.c
T

831 lines
19 KiB
C
Raw Blame History

/*
* Base driver module for Hitachi HD44780 based LCD displays. This is
* a modular driver that readily allows support for alternative HD44780
* designs to be added in a flexible and maintainable manner.
*
* This driver also supports the aggregation of multiple displays to form
* a single virtual display. e.g., Four 16x2 displays can be combined
* to form a 16x8 display.
*
* To add support for additional HD44780 connections:
* 1. Add a connection type and mapping to hd44780-drivers.h
* 2. Call your initialisation routine
* 3. Create the low-level driver (use hd44780-ext8bit.c as a starting point)
* 4. Modify the makefile
*
* Modular driver created and generic support for multiple displays added
* Dec 1999, Benjamin Tse <blt@Comports.com>
*
* This file is released under the GNU General Public License. Refer to the
* COPYING file distributed with this package.
*
* Copyright (c) 2000, 1999, 1995 Benjamin Tse <blt@Comports.com>
* 1999 Andrew McMeikan <andrewm@engineer.com>
* 1998 Richard Rognlie <rrognlie@gamerz.net>
* 1997 Matthias Prinke <m.prinke@trashcan.mcnet.de>
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sys/perm.h>
#include "../../shared/str.h"
#include "lcd.h"
#include "hd44780.h"
#include "drv_base.h"
#include "hd44780-low.h"
#include "hd44780-drivers.h"
// default parallel port address
#ifndef LPTPORT
#define LPTPORT 0x378
#endif
unsigned int port = LPTPORT;
lcd_logical_driver *HD44780;
HD44780_functions *hd44780_functions;
// default value
static enum connectionType connection = HD_4bit;
static int connIdx = 0;
// spanList[line number] = display line number is in
static int *spanList = NULL;
static int numLines = 0;
// dispVOffset is a cumulative sized array of line numbers for each display.
// use this to determine the vertical positioning on a given display
static int *dispVOffset = NULL;
static int numDisplays = 0;
// dispSizes is the vertical size of each display. This is the same as the
// input span list but is kept to save some cpu cycles.
static int *dispSizes = NULL;
// function declarations
void HD44780_flush();
void HD44780_flush_box(int lft, int top, int rgt, int bot);
int HD44780_contrast(int contrast);
void HD44780_backlight(int on);
void HD44780_init_vbar();
void HD44780_init_hbar();
void HD44780_vbar(int x, int len);
void HD44780_hbar(int x, int y, int len);
void HD44780_init_num();
void HD44780_num(int x, int num);
void HD44780_set_char(int n, char *dat);
void HD44780_icon(int which, char dest);
void HD44780_draw_frame(char *dat);
void HD44780_close();
static void HD44780_linewrap(int on);
static void HD44780_autoscroll(int on);
static void HD44780_position(int x, int y);
static void common_position(int display, int DDaddr);
static void common_autoscroll(int on);
static void uPause(int delayCalls);
static void HD44780_senddata(unsigned char displayID,
unsigned char flags,
unsigned char ch);
static int parse_span_list(int *spanListArray[], int *spLsize,
int *dispOffsets[], int *dOffsize,
int *dispSizeArray[], char *spanlist);
/////////////////////////////////////////////////////////////////
// Opens com port and sets baud correctly...
//
int HD44780_init(lcd_logical_driver *driver, char *args)
{
// TODO: remove the two magic numbers below
// TODO: single point of return
char *argv[64], *str;
int argc, i;
HD44780 = driver;
// get_args inserts \0 into args - nasty !
if (args)
if ((str = (char *) malloc(strlen(args) + 1)))
strcpy(str, args);
else
{
fprintf(stderr, "Error mallocing\n");
return -1;
}
else
str = NULL;
argc = get_args(argv, args, 64);
// arguments are passed in with -d HD44780 "-p 0x278"
// getopt will work well here
for(i=0; i<argc; i++)
{
if(0 == strcmp(argv[i], "-p") ||
0 == strcmp(argv[i], "--port"))
{
if(i + 1 >= argc) {
fprintf(stderr, "HD44780_init: %s requires an argument\n",
argv[i]);
return -1;
} else {
int myport;
if (sscanf(argv[i + 1], "%i", &myport) != 1) {
fprintf(stderr, "HD44780_init: Couldn't read port address -"
" using default value 0x%x\n", port);
return -1;
} else {
port = myport;
++i;
}
}
}
else if(0 == strcmp(argv[i], "-c") ||
0 == strcmp(argv[i], "--connect"))
{
int j = 0;
if(i + 1 >= argc) {
fprintf(stderr, "HD44780_init: %s requires an argument\n",
argv[i]);
return -1;
}
// search the next argument for the connection type
for (j = 0;
strcmp(argv[i + 1], connectionMapping[j].connectionTypeStr) != 0
&& connectionMapping[j].type != HD_unknown;
++j)
;
if (connectionMapping[j].type == HD_unknown)
{
fprintf(stderr,
"HD44780_init: Unknown connection type - using default %s driver\n",
connectionMapping[0].connectionTypeStr);
connection = connectionMapping[0].type;
j = 0;
}
else
connection = connectionMapping[j].type;
connIdx = j;
++i;
}
else if(0 == strcmp(argv[i], "-v") ||
0 == strcmp(argv[i], "--vspan"))
{
int j = 0;
if(i + 1 >= argc) {
fprintf(stderr, "HD44780_init: %s requires an argument\n",
argv[i]);
return -1;
}
if (parse_span_list(&spanList, &numLines,
&dispVOffset, &numDisplays,
&dispSizes, argv[i + 1]) == -1)
{
fprintf(stderr, "HD44780_init: invalid vspan argument\n");
return -1;
}
++i;
}
else if(0 == strcmp(argv[i], "-h") ||
0 == strcmp(argv[i], "--help"))
{
int i;
printf("LCDproc HD44780 driver\n"
"\t-p n\t--port n\tSelect the output device to use port n\n"
"\t-c type\t--connect type\tSet the connection type (default 4 bit)\n"
"\t\t\t\ttype = %s", connectionMapping[0].connectionTypeStr);
for (i = 1; connectionMapping[i].type != HD_unknown; ++i)
printf(" | %s", connectionMapping[i].connectionTypeStr);
printf("\n\t-v spanlist\t--vspan spanlist\tvertical span n{,m}\n"
"\t-h\t--help\t\tShow this help information\n"
"\n\tNote that the '-t' option should precede the '-d' option\n");
if (connectionMapping[connIdx].type != HD_unknown)
{
printf("\n Parameters for %s driver\n",
connectionMapping[connIdx].connectionTypeStr);
printf("%s", connectionMapping[connIdx].helpMsg);
}
return -1;
}
/* ignore invalid arguments as they might be valid to the lower-level init
else
{
printf("Invalid parameter: %s\n", argv[i]);
}
*/
}
// default case for when spans aren't indicated
// - add a sanity check against lcd.hgt ??
// - this only works if the -t option is specified before -d
if (numLines == 0)
{
if ((spanList = (int *) malloc(sizeof(int) * lcd.hgt)))
{
int i;
for (i = 0; i < lcd.hgt; ++i)
{
spanList[i] = 1;
numLines = lcd.hgt;
}
}
else
fprintf(stderr, "Error mallocing for span list\n");
}
if (numDisplays == 0)
{
if ((dispVOffset = (int *) malloc(sizeof(int))) &&
(dispSizes = (int *) malloc(sizeof(int))))
{
dispVOffset[0] = 0;
dispSizes[0] = lcd.hgt;
numDisplays = 1;
}
else
fprintf(stderr, "Error mallocing for display sizes list\n");
}
// Set up io port correctly, and open it...
if ((ioperm(port, 1, 255)) == -1) {
fprintf(stderr, "HD44780_init: failed (%s)\n", strerror(errno));
return -1;
}
// Make sure the frame buffer is there...
if (!HD44780->framebuf)
HD44780->framebuf = (unsigned char *) malloc(lcd.wid * lcd.hgt);
if (!HD44780->framebuf) {
//HD44780_close();
return -1;
}
// Set the functions the driver supports...
// These are the default HD44780 functions
driver->clear = (void *)-1;
driver->string = (void *)-1;
driver->chr = (void *)-1;
driver->vbar = HD44780_vbar;
driver->init_vbar = HD44780_init_vbar;
driver->hbar = HD44780_hbar;
driver->init_hbar = HD44780_init_hbar;
driver->num = HD44780_num;
driver->init_num = HD44780_init_num;
driver->init = HD44780_init;
driver->close = (void *)-1;
driver->flush = HD44780_flush;
driver->flush_box = HD44780_flush_box;
driver->contrast = HD44780_contrast;
driver->backlight = HD44780_backlight;
driver->set_char = HD44780_set_char;
driver->icon = HD44780_icon;
driver->draw_frame = HD44780_draw_frame;
driver->getkey = NULL;
if ((hd44780_functions =
(HD44780_functions *) malloc(sizeof(HD44780_functions))) == NULL)
{
return -1;
}
hd44780_functions->uPause = uPause;
hd44780_functions->position = common_position;
hd44780_functions->autoscroll = common_autoscroll;
connectionMapping[connIdx].init_fn(hd44780_functions, driver, str, port);
HD44780_autoscroll(0);
return port;
}
// common initialisation sequence - sets twoline, small characters (5x8),
// cursor off and not blinking, clear display and homecursor
void common_init(enum ifWidth ifwidth)
{
if (ifwidth == IF_8bit)
{
// setup the lcd in 8 bit mode
hd44780_functions->senddata(0, RS_INSTR, FUNCSET | IF_8BIT);
hd44780_functions->uPause(4100);
hd44780_functions->senddata(0, RS_INSTR, FUNCSET | IF_8BIT);
hd44780_functions->uPause(100);
hd44780_functions->senddata(0, RS_INSTR, FUNCSET | IF_8BIT);
hd44780_functions->uPause(40);
}
// else 4bit
// senddata can't generate the timings to initialise a four bit device
// properly but it might just work properly anyway ....
// set display type functions
hd44780_functions->senddata(0,
RS_INSTR,
FUNCSET |
((ifwidth == IF_4BIT) ? IF_4BIT : IF_8BIT) |
TWOLINE | SMALLCHAR);
hd44780_functions->uPause(40);
hd44780_functions->senddata(0,
RS_INSTR,
ONOFFCTRL | DISPON | CURSOROFF | CURSORNOBLINK);
hd44780_functions->uPause(40);
hd44780_functions->senddata(0, RS_INSTR, CLEAR);
hd44780_functions->uPause(1600);
hd44780_functions->senddata(0, RS_INSTR, HOMECURSOR);
hd44780_functions->uPause(1600);
}
// IO delay to avoid a task switch
void uPause(int delayCalls)
{
int i;
for (i = 0; i < delayCalls; ++i)
port_in(port);
//TODO: put in option for nanosleep rather than dummy I/O call
}
// displayID - ID of display to use (0 = all displays)
static void HD44780_senddata(unsigned char displayID, unsigned char flags, unsigned char ch)
{
hd44780_functions->senddata(displayID, flags, ch);
hd44780_functions->uPause(40);
}
/////////////////////////////////////////////////////////////////
// Clean-up
//
/*
void HD44780_close()
{
drv_base_close();
}
*/
// x and y here are for the virtual lcd.hgt x lcd.wid display
static void HD44780_position(int x, int y)
{
int dispID = spanList[y];
int relY = y - dispVOffset[dispID - 1];
int DDaddr;
// 16x1 is a special case
if (dispSizes[dispID - 1] == 1 && lcd.wid == 16)
if (x >= 8)
{
x -= 8; relY = 1;
}
DDaddr = x + (relY % 2) * 0x40;
if ((relY % 4) >= 2)
DDaddr += lcd.wid;
hd44780_functions->position(dispID, DDaddr);
}
void common_position(int display, int DDaddr)
{
hd44780_functions->senddata(display, RS_INSTR, POSITION | DDaddr);
hd44780_functions->uPause(40);
}
void HD44780_flush()
{
HD44780_draw_frame(lcd.framebuf);
}
void HD44780_flush_box(int lft, int top, int rgt, int bot)
{
int x,y;
// printf("Flush (%i,%i)-(%i,%i)\n", lft, top, rgt, bot);
for (y=top; y<=bot; y++) {
HD44780_position(lft,y);
//printf("\n%d,%d :",lft,y);
for (x=lft ; x<=rgt ; x++) {
HD44780_senddata(spanList[y], RS_DATA,
lcd.framebuf[(y*lcd.wid)+x]);
}
//write(fd, lcd.framebuf[(y*lcd.wid)+lft, rgt-lft+1]);
}
}
/////////////////////////////////////////////////////////////////
// Changes screen contrast (0-255; 140 seems good)
//
int HD44780_contrast(int contrast)
{
return 0;
}
/////////////////////////////////////////////////////////////////
// Sets the backlight on or off -- can be done quickly for
// an intermediate brightness...
//
void HD44780_backlight(int on)
{
}
/////////////////////////////////////////////////////////////////
// Toggle the built-in linewrapping feature
//
static void HD44780_linewrap(int on)
{
}
/////////////////////////////////////////////////////////////////
// Toggle the built-in automatic scrolling feature
//
static void HD44780_autoscroll(int on)
{
hd44780_functions->autoscroll(on);
}
void common_autoscroll(int on)
{
hd44780_functions->senddata(0, RS_INSTR,
ENTRYMODE | E_MOVERIGHT |
((on) ? EDGESCROLL : NOSCROLL));
hd44780_functions->uPause(1600);
}
/////////////////////////////////////////////////////////////////
// Sets up for vertical bars. Call before lcd.vbar()
//
void HD44780_init_vbar()
{
char a[] = {
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
1,1,1,1,1,
};
char b[] = {
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
1,1,1,1,1,
1,1,1,1,1,
};
char c[] = {
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
};
char d[] = {
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
};
char e[] = {
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
};
char f[] = {
0,0,0,0,0,
0,0,0,0,0,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
};
char g[] = {
0,0,0,0,0,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
1,1,1,1,1,
};
HD44780_set_char(1,a);
HD44780_set_char(2,b);
HD44780_set_char(3,c);
HD44780_set_char(4,d);
HD44780_set_char(5,e);
HD44780_set_char(6,f);
HD44780_set_char(7,g);
}
/////////////////////////////////////////////////////////////////
// Inits horizontal bars...
//
void HD44780_init_hbar()
{
char a[] = {
1,0,0,0,0,
1,0,0,0,0,
1,0,0,0,0,
1,0,0,0,0,
1,0,0,0,0,
1,0,0,0,0,
1,0,0,0,0,
1,0,0,0,0,
};
char b[] = {
1,1,0,0,0,
1,1,0,0,0,
1,1,0,0,0,
1,1,0,0,0,
1,1,0,0,0,
1,1,0,0,0,
1,1,0,0,0,
1,1,0,0,0,
};
char c[] = {
1,1,1,0,0,
1,1,1,0,0,
1,1,1,0,0,
1,1,1,0,0,
1,1,1,0,0,
1,1,1,0,0,
1,1,1,0,0,
1,1,1,0,0,
};
char d[] = {
1,1,1,1,0,
1,1,1,1,0,
1,1,1,1,0,
1,1,1,1,0,
1,1,1,1,0,
1,1,1,1,0,
1,1,1,1,0,
1,1,1,1,0,
};
HD44780_set_char(1,a);
HD44780_set_char(2,b);
HD44780_set_char(3,c);
HD44780_set_char(4,d);
}
/////////////////////////////////////////////////////////////////
// Draws a vertical bar...
//
void HD44780_vbar(int x, int len)
{
char map[9] = {32, 1, 2, 3, 4, 5, 6, 7, 255 };
int y;
for(y=lcd.hgt; y > 0 && len>0; y--) {
if (len >= lcd.cellhgt)
drv_base_chr(x, y, 255);
else
drv_base_chr(x, y, map[len]);
len -= lcd.cellhgt;
}
}
/////////////////////////////////////////////////////////////////
// Draws a horizontal bar to the right.
//
void HD44780_hbar(int x, int y, int len)
{
char map[6] = { 32, 1, 2, 3, 4, 255 };
for (; x<=lcd.wid && len>0; x++) {
if (len >= lcd.cellwid)
drv_base_chr(x,y,255);
else
drv_base_chr(x, y, map[len]);
len -= lcd.cellwid;
}
}
/////////////////////////////////////////////////////////////////
// Sets up for big numbers.
//
void HD44780_init_num()
{
char out[3];
sprintf(out, "%cn", 254);
//write(fd, out, 2);
}
/////////////////////////////////////////////////////////////////
// Writes a big number.
//
void HD44780_num(int x, int num)
{
char out[5];
sprintf(out, "%c#%c%c", 254, x, num);
//write(fd, out, 4);
}
/////////////////////////////////////////////////////////////////
// Sets a custom character from 0-7...
//
// For input, values > 0 mean "on" and values <= 0 are "off".
//
// The input is just an array of characters...
//
void HD44780_set_char(int n, char *dat)
{
int row, col;
int letter;
if (n < 0 || n > 7) return;
if (!dat) return;
HD44780_senddata(0, RS_INSTR, SETCHAR | n*8);
for(row=0; row < lcd.cellhgt; row++)
{
letter = 0;
for(col=0; col < lcd.cellwid; col++)
{
letter <<= 1;
letter |= (dat[(row * lcd.cellwid) + col] > 0);
}
HD44780_senddata(0, RS_DATA, letter);
}
}
void HD44780_icon(int which, char dest)
{
char icons[3][5*8] = {
{
1,1,1,1,1, // Empty Heart
1,0,1,0,1,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
1,0,0,0,1,
1,1,0,1,1,
1,1,1,1,1,
},
{
1,1,1,1,1, // Filled Heart
1,0,1,0,1,
0,1,0,1,0,
0,1,1,1,0,
0,1,1,1,0,
1,0,1,0,1,
1,1,0,1,1,
1,1,1,1,1,
},
{
0,0,0,0,0, // Ellipsis
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
1,0,1,0,1,
},
};
HD44780_set_char(dest, &icons[which][0]);
}
/////////////////////////////////////////////////////////////
// Blasts a single frame onscreen, to the lcd...
//
// Input is a character array, sized lcd.wid*lcd.hgt
//
void HD44780_draw_frame(char *dat)
{
int x,y;
if (!dat) return;
for (y=0; y<lcd.hgt; y++) {
HD44780_position(0,y);
//printf("\n%d :",y);
for (x=0 ; x<lcd.wid ; x++) {
HD44780_senddata(spanList[y],RS_DATA,dat[(y*lcd.wid)+x]);
}
}
}
// Parse the span list
// spanListArray - array to store vertical spans
// spLsize - size of spanListArray
// dispOffsets - array to store display offsets
// dOffsize - size of dispOffsets
// dispSizeArray - array of display vertical sizes (= spanlist)
// spanlist - null terminated input span list in comma delimited
// format. All span elements [1-9] e.g. "1,4,2"
// returns number of span elements, -1 on parse error
int
parse_span_list(int *spanListArray[], int *spLsize,
int *dispOffsets[], int *dOffsize,
int *dispSizeArray[], char *spanlist)
{
int j = 0, retVal = 0;
*spLsize = 0;
*dOffsize = 0;
while (j < strlen(spanlist))
{
if (spanlist[j] >= '1' && spanlist[j] <= '9')
{
int spansize = spanlist[j] - '0';
// add spansize lines to the span list, note the offset to
// the previous display and the size of the display
if ((*spanListArray = (int *) realloc(*spanListArray,
sizeof(int) * (*spLsize + spansize)))
&& (*dispOffsets = (int *) realloc(*dispOffsets,
sizeof(int) * (*dOffsize + 1)))
&& (*dispSizeArray = (int *) realloc(*dispSizeArray,
sizeof(int) * (*dOffsize + 1))))
{
int k;
for (k = 0; k < spansize; ++k)
(*spanListArray)[*spLsize + k] = *dOffsize + 1;
(*dispOffsets)[*dOffsize] = *spLsize;
(*dispSizeArray)[*dOffsize] = spansize;
*spLsize += spansize;
++(*dOffsize);
retVal = *dOffsize;
// find the next number (\0 is also outside this range)
for ( ++j; spanlist[j] < '1' || spanlist[j] > '9'; ++j)
;
}
else
{
fprintf(stderr, "Error reallocing for span list\n");
retVal -1;
}
}
else
{
fprintf(stderr, "Error reading spansize\n");
retVal = -1;
}
}
return retVal;
}
Reference in New Issue View Git Blame Copy Permalink