/* $Id$
* $URL$
*
* math plugin
*
* Copyright (C) 2003 Michael Reinelt <michael@reinelt.co.at>
* Copyright (C) 2004 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
*
* This file is part of LCD4Linux.
*
* LCD4Linux 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 2, or (at your option)
* any later version.
*
* LCD4Linux is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY/* $Id$
* $URL$
*
* driver for a simple serial terminal.
*
* Copyright (C) 2005 Julien Aube <ob@obconseil.net>
* Copyright (C) 2005 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
*
* This file is part of LCD4Linux.
*
* LCD4Linux 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 2, or (at your option)
* any later version.
*
* LCD4Linux 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, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
/*
* This driver simply send out caracters on the serial port, without any
* formatting instructions for a particular LCD device.
* This is useful for custom boards of for very simple LCD.
*
* I use it for tests on a custom-made board based on a AVR microcontroler
* and also for driver a Point-of-Sale text-only display.
* I assume the following :
* - CR (0x0d) Return to the begining of the line without erasing,
* - LF (0x0a) Initiate a new line (but without sending the cursor to
* the begining of the line)
* - BS (0x08) Move the cursor to the previous caracter (but does no erase it).
* - It's not possible to return to the first line. Thus a back buffer is used
* in this driver.
*
* ******** UPDATE *********
* I have added a "VT-100 Compatible mode" that allows the driver to support
* control-sequence code. This greatly reduce flickering and eliminate the need
* for the back-buffer. But it is optional since all displays cannot support them.
* Here are the codes:
* Delete the display (but does not move the cursor) :
* "ESC [ 2 J" (0x1b 0x5b 0x32 0x4a)
* Position the cursor :
* "ESC [ YY ; XX H" ( 0x1b 0x5b YY 0x3b XX 0x48 ) where YY is the ascii for the line
* number, and XX is the ascii for the column number ( first line/column is '1', not zero)
* Delete to the end of line from current cursor position :
* "ESC [ 0 K" ( 0x1b 0x5b 0x30 0x4b )
* Set Country Code :
* "ESC R NN" (0x1b 0x52 NN) where NN is the country code *in byte, NOT ascii*.
* The default is 0 (USA), see below for specific countries.
* the list of accessible characters page are available on this page :
* http://www.wincor-nixdorf.com/internet/com/Services/Support/TechnicalSupport/POSSystems
* /Manuals/BAxx/index.html
* Get the display identification : (Doesn't work reliably, timing issues here)
* "ESC [ 0 c" ( 0x1b 0x5b 0x30 0x63). Return a string which look like this :
* ESC [ ? M ; NN ; OO ; PP ; QQ c) where M is type of display (2 for VFD),
* NN is the rom version, 00 is the current caracter set, PP is the number of lines and
* QQ the number of colomns.
*
*
* A "bar" capability is now provided if the config file has a "BarCharValue" parameter in it.
*
* The code come mostly taken from the LCDTerm driver in LCD4Linux, from
* Michaels Reinelt, many thanks to him.
*
* This driver is released under the GPL.
*/
/*
*
* exported fuctions:
*
* struct DRIVER drv_SimpleLCD
*
*/
#include "config.h"
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "debug.h"
#include "cfg.h"
#include "qprintf.h"
#include "plugin.h"
#include "widget.h"
#include "widget_text.h"
#include "widget_icon.h"
#include "widget_bar.h"
#include "drv.h"
#include "drv_generic_text.h"
#include "drv_generic_serial.h"
static char Name[] = "SimpleLCD";
static char *backbuffer = 0;
static int backbuffer_size = 0;
static int vt100_mode = 0;
static unsigned char bar_char = 0;
/****************************************/
/*** hardware dependant functions ***/
/****************************************/
/** No clear function on SimpleLCD : Just send CR-LF * number of lines **/
static void drv_SL_simple_clear(void)
{
char cmd[2];
int i;
cmd[0] = '\r';
cmd[1] = '\n';
for (i = 0; i < DROWS; ++i) {
drv_generic_serial_write(cmd, 2);
}
memset(backbuffer, ' ', backbuffer_size);
}
/** vt-100 mode : send the ESC-code **/
static void drv_SL_vt100_clear(void)
{
char cmd[4];
cmd[0] = 0x1b;
cmd[1] = '[';
cmd[2] = '2';
cmd[3] = 'J';
drv_generic_serial_write(cmd, 4);
}
static void drv_SL_clear(void)
{
vt100_mode == 1 ? drv_SL_vt100_clear() : drv_SL_simple_clear();
}
/* If full_commit = true, then the whole buffer is to be sent to screen.
if full_commit = false, then only the last line is to be sent (faster on slow screens)
*/
static void drv_SL_commit(int full_commit)
{
int row;
char cmd[2] = { '\r', '\n' };
if (full_commit) {
for (row = 0; row < DROWS; row++) {
drv_generic_serial_write(cmd, 2);
drv_generic_serial_write(backbuffer + (DCOLS * row), DCOLS);
}
} else {
drv_generic_serial_write(cmd, 1); /* Go to the beginning of the line only */
drv_generic_serial_write(backbuffer + (DCOLS * (DROWS - 1)), DCOLS);
}
}
static void drv_SL_simple_write(const int row, const int col, const char *data, int len)
{
memcpy(backbuffer + (row * DCOLS) + col, data, len);
if (row == DROWS - 1)
drv_SL_commit(0);
else
drv_SL_commit(1);
}
static void drv_SL_vt100_write(const int row, const int col, const char *data, int len)
{
char cmd[8];
cmd[0] = 0x1b;
cmd[1] = '[';
cmd[2] = row + '1';
cmd[3] = ';';
cmd[4] = (col / 10) + '0';
cmd[5] = (col % 10) + '1';
cmd[6] = 'H';
drv_generic_serial_write(cmd, 7);
drv_generic_serial_write(data, len);
}
static int drv_SL_start(const char *section, const int quiet)
{
int rows = -1, cols = -1;
int value;
unsigned int flags = 0;
char *s;
char *model = 0;
vt100_mode = 0;
model = cfg_get(section, "Model", "generic");
if (model != NULL && *model != '\0') {
if (strcasecmp("vt100", model) == 0)
vt100_mode = 1;
}
cfg_number(section, "BarCharValue", 0, 0, 255, &value);
bar_char = value;
cfg_number(section, "Options", 0, 0, 0xffff, &value);
flags = value;
if (drv_generic_serial_open(section, Name, flags) < 0)
return -1;
s = cfg_get(section, "Size", NULL);
if (s == NULL || *s == '\0') {
error("%s: no '%s.Size' entry from %s", Name, section, cfg_source());
return -1;
}
if (sscanf(s, "%dx%d", &cols, &rows) != 2 || rows < 1 || cols < 1) {
error("%s: bad %s.Size '%s' from %s", Name, section, s, cfg_source());
free(s);
return -1;
}
DROWS = rows;
DCOLS = cols;
if (!vt100_mode) {
backbuffer_size = DROWS * DCOLS;
backbuffer = malloc(backbuffer_size);
if (!backbuffer) {
return -1;
}
}
/* real worker functions */
if (vt100_mode) {
drv_generic_text_real_write = drv_SL_vt100_write;
} else {
drv_generic_text_real_write = drv_SL_simple_write;
}
drv_SL_clear(); /* clear */
if (!quiet) {
char buffer[40];
qprintf(buffer, sizeof(buffer), "%s %dx%d", Name, DCOLS, DROWS);
if (drv_generic_text_greet(buffer, NULL)) {
sleep(3);
drv_SL_clear();
}
}
return 0;
}
/****************************************/
/*** plugins ***/
/****************************************/
/* none */
/****************************************/
/*** widget callbacks ***/
/****************************************/
/* using drv_generic_text_draw(W) */
/****************************************/
/*** exported functions ***/
/****************************************/
/* list models */
int drv_SL_list(void)
{
printf("generic vt100");
return 0;
}
/* initialize driver & display */
int drv_SL_init(const char *section, const int quiet)
{
WIDGET_CLASS wc;
int ret;
info("%s: %s", Name, "$Rev$");
/* display preferences */
XRES = 5; /* pixel width of one char */
YRES = 8; /* pixel height of one char */
CHARS = 0; /* number of user-defineable characters */
CHAR0 = 0; /* ASCII of first user-defineable char */
GOTO_COST = -1; /* number of bytes a goto command requires */
/* start display */
if ((ret = drv_SL_start(section, quiet)) != 0)
return ret;
/* initialize generic text driver */
if ((ret = drv_generic_text_init(section, Name)) != 0)
return ret;
/* register text widget */
wc = Widget_Text;
wc.draw = drv_generic_text_draw;
widget_register(&wc);
/* register plugins */
/* none */
return 0;
}
/* close driver & display */
int drv_SL_quit(const int quiet)
{
info("%s: shutting down.", Name);
drv_generic_text_quit();
/* clear display */
drv_SL_clear();
/* say goodbye... */
if (!quiet) {
drv_generic_text_greet("goodbye!", NULL);
}
drv_generic_serial_close();
if (backbuffer) {
free(backbuffer);
backbuffer = 0;
backbuffer_size = 0;
}
return (0);
}
DRIVER drv_SimpleLCD = {
.name = Name,
.list = drv_SL_list,
.init = drv_SL_init,
.quit = drv_SL_quit,
};