mangavalk/lcdproc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3fa9bc355b646260f4e1443059fe337e49c0166d
lcdproc/server/drivers/glk.c
T
ddouthitt 226ec0c7b2 Updated glk driver: 
* Removed all reference to lcd.* ; replaced with glk->*

Field testing is required.
2001-09-25 16:53:07 +00:00

676 lines
17 KiB
C
Raw Blame History

/*
* MatrixOrbital GLK Graphic Display Driver
*
* http://www.matrixorbital.com
*
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <termios.h>
#include <fcntl.h>
#include <string.h>
#include <sys/errno.h>
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
#endif
#include "lcd.h"
#include "shared/str.h"
#include "glk.h"
#include "glkproto.h"
static GLKDisplay * PortFD ;
/* Initialize pseudo-CGRAM to empty */
static unsigned char CGRAM[8] = { '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' };
//////////////////////////////////////////////////////////////////////////
//////////////////// Matrix Orbital Graphical Driver /////////////////////
//////////////////////////////////////////////////////////////////////////
lcd_logical_driver *glk;
static unsigned char * screen_contents = NULL ;
int fontselected = 0 ;
int gpo_count = 0 ;
// TODO: Get lcd.framebuf to properly work as whatever driver is running...
////////////////////////////////////////////////////////////
// init() should set up any device-specific stuff, and
// point all the function pointers.
int glk_init(struct lcd_logical_driver *driver, char *args)
{
char * argv[64];
int argc;
char * device = "/dev/lcd" ;
int contrast = 140;
speed_t speed = B19200 ;
int i ;
int width ;
int height ;
// printf("glk_init()\n");
glk = driver;
argc = get_args( argv, args, 64 );
for( i = 0 ; i < argc; ++i ) {
if( 0 == strcmp( argv[i], "-d")
|| 0 == strcmp( argv[i], "--device" )
) {
if( i+1 >= argc ) {
fprintf( stderr, "glk: %s requires an argument\n", argv[i]);
return( -1 );
};
device = argv[i+1] ;
++i ;
} else if( 0 == strcmp( argv[i], "-c" )
|| 0 == strcmp( argv[i], "--contrast" )
) {
int tmp ;
if( i+1 >= argc ) {
fprintf( stderr, "glk: %s requires an argument\n", argv[i]);
return( -1 );
};
tmp = atoi( argv[i+1] );
if( tmp < 0 || tmp > 255 ) {
fprintf( stderr, "glk: %s argument must be between 0 and 255\n", argv[i]);
} else {
contrast = tmp ;
};
++i ;
} else if( 0 == strcmp( argv[i], "-s" )
|| 0 == strcmp( argv[i], "--speed" )
) {
int tmp ;
if( i+1 >= argc ) {
fprintf( stderr, "glk: %s requires an argument\n", argv[i]);
return( -1 );
};
tmp = atoi( argv[i+1] );
if( tmp == 9600 ) {
speed = B9600 ;
} else if( tmp == 19200 ) {
speed = B19200 ;
} else if( tmp == 38400 ) {
speed = B38400 ;
} else {
fprintf( stderr, "glk: %s argument (%s) not a valid speed.\n", argv[i], argv[i+1] );
};
++i ;
} else if( 0 == strcmp( argv[i], "-h" )
|| 0 == strcmp( argv[i], "--help" )
) {
printf(
"LCDproc Matrix-Orbital GLK Graphical LCD driver\n"
"\n"
"-d, --device select the serial device to use [/dev/lcd]\n"
"-c, --contrast set the initial contrast value [140]\n"
"-s, --speed set the serial port speed [19200]\n"
"-h, --help display this help text\n"
);
return( -1 );
} else {
fprintf( stderr, "glk: Invalid parameter: %s\n", argv[i] );
};
};
PortFD = glkopen( device, speed );
if( PortFD == NULL ) {
return -1 ;
};
// Query the module for a device type
glkputl( PortFD, GLKCommand, 0x37, EOF );
i = glkget( PortFD );
if( i < 0 ) {
fprintf( stderr, "glk: GLK did not respond to READ MODULE TYPE.\n" );
return -1 ;
} else {
switch( i ) {
case 0x10 : // GLC12232
width = 20 ; height = 4 ; break ;
case 0x11 : // GLC12864
width = 20 ; height = 8 ; break ;
case 0x12 : // GLC128128
width = 20 ; height = 16 ; break ;
case 0x13 : // GLC24064
width = 40 ; height = 8 ; gpo_count = 1 ; break ;
case 0x14 : // GLK12864-25
width = 20 ; height = 8 ; break ;
case 0x15 : // GLK24064-25
width = 40 ; height = 8 ; gpo_count = 1 ; break ;
case 0x21 : // GLK128128-25
width = 20 ; height = 16 ; break ;
case 0x22 : // GLK12232-25
width = 20 ; height = 4 ; gpo_count = 2 ; break ;
case 0x23 : // GLK12232-25SM
width = 20 ; height = 4 ; gpo_count = 2 ; break ;
case 0x24 : // GLK12232-25SM-Penguin
width = 20 ; height = 4 ; gpo_count = 2 ; break ;
default :
fprintf( stderr, "glk: Unrecognized module type: 0x%02x\n", i );
return( -1 );
};
};
driver->wid = width ;
driver->hgt = height ;
// You must use driver->framebuf here, but may use lcd.framebuf later.
if(!driver->framebuf) {
driver->framebuf = malloc(driver->wid * driver->hgt);
};
screen_contents = malloc( driver->wid * driver->hgt );
if(driver->framebuf == NULL || screen_contents == NULL ) {
fprintf( stderr, "glk: Unable to allocate memory for screen buffers\n" );
glk_close();
return -1;
}
memset(driver->framebuf, ' ', driver->wid*driver->hgt);
// glk_clear();
// glkputl( PortFD, GLKCommand, 0x58, EOF );
// No font selected
fontselected = -1 ;
// Enable flow control
glkflow( PortFD, 40, 2 );
// Set read character timeout to 0
glktimeout( PortFD, 0 );
// Enable auto-transmit of up/down key events
// This allows us to generate REPEAT keys distinct from
// normal keys using timeouts. (see glk_getkey)
glkputl( PortFD, GLKCommand, 0x7e, 1, GLKCommand, 0x41, EOF );
// Set contrast
glk_contrast( contrast );
driver->cellwid = 5;
driver->cellhgt = 8;
driver->clear = glk_clear;
driver->string = glk_string;
driver->chr = glk_chr;
driver->vbar = glk_vbar;
driver->init_vbar = glk_init_vbar;
driver->hbar = glk_hbar;
driver->init_hbar = glk_init_hbar;
driver->num = glk_num ;
driver->init_num = glk_init_num ;
driver->init = glk_init;
driver->close = glk_close;
driver->flush = glk_flush;
driver->flush_box = glk_flush_box;
driver->contrast = glk_contrast;
driver->backlight = glk_backlight;
driver->output = glk_output;
driver->set_char = glk_set_char;
driver->icon = glk_icon;
driver->draw_frame = glk_draw_frame;
driver->getkey = glk_getkey;
return 200; // 200 is arbitrary. (must be 1 or more)
}
// Below here, you may use either lcd.framebuf or driver->framebuf..
// lcd.framebuf will be set to the appropriate buffer before calling
// your driver.
void glk_close()
{
if(glk->framebuf != NULL) free(glk->framebuf);
glk->framebuf = NULL;
glkclose( PortFD ) ;
}
/////////////////////////////////////////////////////////////////
// Clears the LCD screen
//
#define CLEARCOUNT (1000000)
static int clearcount = 0 ;
void glk_clear_forced()
{
// puts( "REALLY CLEARING the display" );
clearcount = CLEARCOUNT ;
glkputl( PortFD, GLKCommand, 0x58, EOF );
memset(screen_contents, ' ', glk->wid*glk->hgt);
}
void glk_clear()
{
// puts( "glk_clear( )" );
memset(glk->framebuf, ' ', glk->wid*glk->hgt);
if( --clearcount < 0 ) {
glk_clear_forced( );
};
}
//////////////////////////////////////////////////////////////////
// Flushes all output to the lcd...
//
void glk_flush()
{
// puts( "glk_flush( )" );
glk->draw_frame(glk->framebuf);
}
/////////////////////////////////////////////////////////////////
// Prints a string on the lcd display, at position (x,y). The
// upper-left is (1,1), and the lower right should be (20,4).
//
void glk_string(int x, int y, char string[])
{
char * p ;
// printf( "glk_string( %d, %d, \"%s\" )\n", x, y, string );
if( x > glk->wid || y > glk->hgt ) {
return ;
};
for( p = string ; *p && x <= glk->wid ; ++x, ++p ) {
glk_chr( x, y, *p );
};
}
/////////////////////////////////////////////////////////////////
// Prints a character on the lcd display, at position (x,y). The
// upper-left is (1,1), and the lower right should be (20,4).
//
void glk_chr(int x, int y, char c)
{
int myc = (unsigned char) c ;
x -= 1; // Convert 1-based coords to 0-based...
y -= 1;
if( fontselected != 2 ) {
// puts( "Switching to font 2" );
/* Select font 2 */
glkputl( PortFD, GLKCommand, 0x31, 2, EOF );
fontselected = 2 ;
/* Set font metrics */
glkputl( PortFD, GLKCommand, 0x32, 1, 0, 1, 1, 32, EOF );
/* Clear the screen */
glk_clear_forced( );
};
if( myc >= 0 && myc <= 15 ) {
/* CGRAM */
// if( myc != 0 ) {
// printf( "CGRAM changing %d => %d\n", myc, CGRAM[myc&7] );
// };
myc = CGRAM[myc&7] ;
} else if( myc == 255 || myc == -1 ) {
/* Solid block */
myc = 133 ;
} else if( (myc > 15 && myc < 32) || myc > 143 ) {
fprintf( stderr, "Attempt to write %d to (%d,%d)\n", myc, x, y );
myc = 133 ;
};
glk->framebuf[(y*glk->wid) + x] = myc;
}
//////////////////////////////////////////////////////////////////////
// Sets the contrast of the display. Value is 0-255, where 140 is
// what I consider "just right".
//
int glk_contrast(int contrast)
{
static int saved_contrast = 140 ;
if( contrast > 0 && contrast < 256 ) {
saved_contrast = contrast ;
// printf("Contrast: %i\n", contrast);
glkputl( PortFD, GLKCommand, 0x50, contrast, EOF );
};
return( saved_contrast );
}
//////////////////////////////////////////////////////////////////////
// Turns the lcd backlight on or off...
//
void glk_backlight(int on)
{
if(on) {
// printf("Backlight ON\n");
glkputl( PortFD, GLKCommand, 0x42, 0, EOF );
} else {
// printf("Backlight OFF\n");
glkputl( PortFD, GLKCommand, 0x46, EOF );
}
}
//////////////////////////////////////////////////////////////////////
// Sets general purpose outputs on or off
void
glk_output(int on)
{
if( gpo_count < 2 ) {
if( on ) { glkputl( PortFD, GLKCommand, 'W', EOF );
} else { glkputl( PortFD, GLKCommand, 'V', EOF );
};
} else {
int i;
for( i = 1 ; i <= gpo_count ; ++i, on >>= 1 ) {
if( on & 1 ) {
glkputl( PortFD, GLKCommand, 'W', i, EOF );
} else {
glkputl( PortFD, GLKCommand, 'V', i, EOF );
};
};
};
}
//////////////////////////////////////////////////////////////////////
// Tells the driver to get ready for vertical bargraphs.
//
void glk_init_vbar()
{
// printf("Vertical bars.\n");
}
//////////////////////////////////////////////////////////////////////
// Tells the driver to get ready for horizontal bargraphs.
//
void glk_init_hbar()
{
// printf("Horizontal bars.\n");
}
//////////////////////////////////////////////////////////////////////
// Tells the driver to get ready for big numbers, if possible.
//
void glk_init_num()
{
// printf("Big Numbers.\n");
if( fontselected != 3 ) {
/* Select Big Numbers font */
glkputl( PortFD, GLKCommand, 0x31, 3, EOF );
fontselected = 3 ;
/* Set font metrics */
glkputl( PortFD, GLKCommand, 0x32, 1, 0, 1, 1, 32, EOF );
/* Clear the screen */
glk_clear_forced( );
};
}
//////////////////////////////////////////////////////////////////////
// Draws a big (4-row) number.
//
void glk_num(int x, int num)
{
// printf("BigNum(%i, %i)\n", x, num);
glk->framebuf[x-1] = num + '0' ;
}
//////////////////////////////////////////////////////////////////////
// Changes the font data of character n.
//
void glk_set_char(int n, char *dat)
{
printf("Set Character %i\n", n);
}
/////////////////////////////////////////////////////////////////
// Draws a vertical bar, from the bottom of the screen up.
//
void glk_vbar(int x, int len)
{
int y = glk->hgt ;
// printf( "glk_vbar( %d, %d )\n", x, len );
while( len > glk->cellhgt ) {
glk_chr( x, y, 255 );
--y ;
len -= glk->cellhgt ;
};
if( y >= 0 ) {
int lastc ;
switch( len ) {
case 0 : return ; break ; /* Don't output a char */
case 1 : lastc = 138 ; break ; /* One bar */
case 2 : lastc = 139 ; break ;
case 3 : lastc = 140 ; break ;
case 4 : lastc = 141 ; break ;
case 5 : lastc = 142 ; break ;
case 6 : lastc = 143 ; break ;
default: lastc = 133 ; break ;
};
glk_chr( x, y, lastc );
};
}
/////////////////////////////////////////////////////////////////
// Draws a horizontal bar to the right.
//
void glk_hbar(int x, int y, int len)
{
// printf( "glk_hbar( %d, %d, %d )\n", x, y, len );
while( len > glk->cellwid ) {
glk_chr( x, y, 255 );
++x ;
len -= glk->cellwid ;
};
if( x <= glk->wid ) {
int lastc ;
switch( len ) {
case 0 : lastc = ' ' ; break ;
case 1 : lastc = 134 ; break ; /* One bar */
case 2 : lastc = 135 ; break ;
case 3 : lastc = 136 ; break ;
case 4 : lastc = 137 ; break ;
default: lastc = 133 ; break ;
};
glk_chr( x, y, lastc );
};
}
/////////////////////////////////////////////////////////////////
// Sets character 0 to an icon...
//
void glk_icon(int which, char dest)
{
unsigned char old, new ;
unsigned char * p ;
unsigned char * q ;
int count ;
// printf("Char %i set to icon %i\n", dest, which);
if( dest < 0 || dest > 7 ) {
/* Illegal custom character */
return ;
};
/* which == 0 => empty heart => 131
* which == 1 => filled heart => 132
* which == 2 => ellipsis => 128
*/
switch( which ) {
case 0: new = 131 ; break ;
case 1: new = 132 ; break ;
case 2: new = 128 ; break ;
default: return ; /* ERROR */
};
old = CGRAM[(int)dest] ;
CGRAM[(int)dest] = new ;
p = glk->framebuf ;
q = screen_contents ;
/* Replace all old icons with new icon in new frame */
for( count = glk->wid * glk->hgt ; count ; --count ) {
if( *q == old ) {
// printf( "icon %d to %d at %d\n", old, new, q - screen_contents );
*p = new ;
};
++q ; ++p ;
};
return ;
}
//////////////////////////////////////////////////////////////////////
// Send a rectangular area to the display.
//
// I've just called glk_flush() because there's not much point yet
// in flushing less than the entire framebuffer.
//
void glk_flush_box(int lft, int top, int rgt, int bot)
{
// printf("glk_flush_box( %d, %d, %d, %d )\n", lft, top, rgt, bot );
glk_flush( );
}
//////////////////////////////////////////////////////////////////////
// Draws the framebuffer on the display.
//
// The commented-out code is from the text driver.
//
void glk_draw_frame(char *dat)
{
char * p ;
char * q ;
int x, y ;
int xs ;
char * ps = NULL ;
// printf( "glk_draw_frame( %p ) glk->framebuf = %p\n", dat, glk->framebuf );
p = glk->framebuf ;
q = screen_contents ;
for( y = 0 ; y < glk->hgt ; ++y ) {
xs = -1 ; /* XStart not set */
for( x = 0 ; x < glk->wid ; ++x ) {
if( *q == *p && xs >= 0 ) {
/* Write accumulated string */
glkputl( PortFD, GLKCommand, 0x79, xs*6+1, y*8, EOF );
glkputa( PortFD, x - xs, ps );
// printf( "draw_frame: Writing at (%d,%d) for %d\n", xs, y, x-xs );
xs = -1 ;
} else if( *q != *p && xs < 0 ) {
/* Start new string of changes */
ps = p ;
xs = x ;
};
*q++ = *p++ ; /* Update screen_contents from glk->framebuf */
};
if( xs >= 0 ) {
/* Write accumulated line */
glkputl( PortFD, GLKCommand, 0x79, xs*6+1, y*8, EOF );
glkputa( PortFD, glk->wid - xs, ps );
// printf( "draw_frame: Writing at (%d,%d) for %d\n", xs, y, glk->wid-xs );
};
}; /* For y */
return ;
}
//////////////////////////////////////////////////////////////////////
// Tries to read a character from an input device...
//
// Return 0 for "nothing available".
//
char glk_getkey()
{
int c ;
static int key = -1 ;
static struct timeval lastkey ;
struct timeval now ;
// puts( "glk_getkey( )" );
c = glkgetc( PortFD );
if( c >= 'A' && c <= 'Z' ) {
/* Key down event */
key = c ;
gettimeofday( &lastkey, NULL );
// printf( "KEY %c at %ld.%06ld\n", c, lastkey.tv_sec, lastkey.tv_usec );
} else if( c >= 'a' && c <= 'z' ) {
/* Key up event */
// printf( "KEY %c UP\n", c );
key = -1 ;
c = 0 ;
} else {
/* Assume timeout */
c = 0 ;
if( key > 0 ) {
int msec_diff ;
/* A key is down */
gettimeofday( &now, NULL );
msec_diff = (now.tv_sec - lastkey.tv_sec) * 1000 ;
msec_diff += (now.tv_usec - lastkey.tv_usec) / 1000 ;
// printf( "KEY %c down for %d msec\n", key, msec_diff );
if( msec_diff > 1000 ) {
/* Generate repeat event */
c = key | 0x20 ; /* Upper case to lower case */
++lastkey.tv_sec ; /* HACK HACK. repeat at 1 sec intervals */
// printf( "KEY %c REPEAT\n", c );
};
};
};
/* Remap keys according to what LCDproc expects */
switch( c ) {
default : break ;
case 'V' : c = 'A' ; break ; /* Hold/Select */
case 'P' : c = 'B' ; break ; /* Left -- Minus */
case 'Q' : c = 'C' ; break ; /* Right -- Plus */
case 'L' : c = 'D' ; break ; /* Menu/Exit */
case 'U' : c = 'E' ; break ; /* Up */
case 'K' : c = 'F' ; break ; /* Down */
case 'v' : c = 'N' ; break ;
case 'p' : c = 'O' ; break ;
case 'q' : c = 'P' ; break ;
case 'l' : c = 'Q' ; break ;
case 'u' : c = 'R' ; break ;
case 'k' : c = 'S' ; break ;
};
// if( c ) {
// printf( "KEY %c\n", c );
// };
return( c );
}
Reference in New Issue View Git Blame Copy Permalink