yan/archived-lcd4linux
1
0
Fork 0
mirror of https://github.com/netfun2000/lcd4linux.git synced 2026-02-27 09:44:34 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
aec024c84b626ee9d8a0a8cdfeea2b7e868c5b5b
archived-lcd4linux/MatrixOrbital.c
reinelt f738480140 [lcd4linux @ 2001-02-14 07:40:16 by reinelt] 
first (incomplete) GPO implementation

git-svn-id: https://ssl.bulix.org/svn/lcd4linux/trunk@80 3ae390bd-cb1e-0410-b409-cd5a39f66f1f
2001-02-14 07:40:16 +00:00

621 lines
13 KiB
C
Raw Blame History

/* $Id: MatrixOrbital.c,v 1.21 2001/02/14 07:40:16 reinelt Exp $
*
* driver for Matrix Orbital serial display modules
*
* Copyright 1999, 2000 by Michael Reinelt (reinelt@eunet.at)
*
* 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 2, 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, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*
* $Log: MatrixOrbital.c,v $
* Revision 1.21 2001/02/14 07:40:16 reinelt
*
* first (incomplete) GPO implementation
*
* Revision 1.20 2001/02/13 09:00:13 reinelt
*
* prepared framework for GPO's (general purpose outputs)
*
* Revision 1.19 2000/08/10 09:44:09 reinelt
*
* new debugging scheme: error(), info(), debug()
* uses syslog if in daemon mode
*
* Revision 1.18 2000/08/09 09:50:29 reinelt
*
* opened 0.98 development
* removed driver-specific signal-handlers
* added 'quit'-function to driver structure
* added global signal-handler
*
* Revision 1.17 2000/04/15 11:13:54 reinelt
*
* added '-d' (debugging) switch
* added several debugging messages
* removed config entry 'Delay' for HD44780 driver
* delay loop for HD44780 will be calibrated automatically
*
* Revision 1.16 2000/04/13 06:09:52 reinelt
*
* added BogoMips() to system.c (not used by now, maybe sometimes we can
* calibrate our delay loop with this value)
*
* added delay loop to HD44780 driver. It seems to be quite fast now. Hopefully
* no compiler will optimize away the delay loop!
*
* Revision 1.15 2000/04/12 08:05:45 reinelt
*
* first version of the HD44780 driver
*
* Revision 1.14 2000/04/10 04:40:53 reinelt
*
* minor changes and cleanups
*
* Revision 1.13 2000/04/07 05:42:20 reinelt
*
* UUCP style lockfiles for the serial port
*
* Revision 1.12 2000/03/26 18:46:28 reinelt
*
* bug in pixmap.c that leaded to empty bars fixed
* name conflicts with X11 resolved
*
* Revision 1.11 2000/03/25 05:50:43 reinelt
*
* memory leak in Raster_flush closed
* driver family logic changed
*
* Revision 1.10 2000/03/23 07:24:48 reinelt
*
* PPM driver up and running (but slow!)
*
* Revision 1.9 2000/03/22 07:33:50 reinelt
*
* FAQ added
* new modules 'processor.c' contains all data processing
*
* Revision 1.8 2000/03/19 08:41:28 reinelt
*
* documentation available! README, README.MatrixOrbital, README.Drivers
* added Skeleton.c as a starting point for new drivers
*
* Revision 1.7 2000/03/18 08:07:04 reinelt
*
* vertical bars implemented
* bar compaction improved
* memory information implemented
*
* Revision 1.6 2000/03/17 09:21:42 reinelt
*
* various memory statistics added
*
* Revision 1.5 2000/03/13 15:58:24 reinelt
*
* release 0.9
* moved row parsing to parser.c
* all basic work finished
*
* Revision 1.4 2000/03/10 17:36:02 reinelt
*
* first unstable but running release
*
*/
/*
*
* exported fuctions:
*
* struct LCD MatrixOrbital[]
*
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <termios.h>
#include <fcntl.h>
#include "debug.h"
#include "cfg.h"
#include "lock.h"
#include "display.h"
#define XRES 5
#define YRES 8
#define CHARS 8
#define BARS ( BAR_L | BAR_R | BAR_U | BAR_D | BAR_H2 )
typedef struct {
int len1;
int len2;
int type;
int segment;
} BAR;
typedef struct {
int len1;
int len2;
int type;
int used;
int ascii;
} SEGMENT;
static LCD Lcd;
static char *Port=NULL;
static speed_t Speed;
static int Device=-1;
static char Txt[4][40];
static BAR Bar[4][40];
static int GPO;
static int nSegment=2;
static SEGMENT Segment[128] = {{ len1:0, len2:0, type:255, used:0, ascii:32 },
{ len1:255, len2:255, type:255, used:0, ascii:255 }};
static int MO_open (void)
{
int fd;
pid_t pid;
struct termios portset;
if ((pid=lock_port(Port))!=0) {
if (pid==-1)
error ("MatrixOrbital: port %s could not be locked", Port);
else
error ("MatrixOrbital: port %s is locked by process %d", Port, pid);
return -1;
}
fd = open(Port, O_RDWR | O_NOCTTY | O_NDELAY);
if (fd==-1) {
error ("MatrixOrbital: open(%s) failed: %s", Port, strerror(errno));
return -1;
}
if (tcgetattr(fd, &portset)==-1) {
error ("MatrixOrbital: tcgetattr(%s) failed: %s", Port, strerror(errno));
return -1;
}
cfmakeraw(&portset);
cfsetospeed(&portset, Speed);
if (tcsetattr(fd, TCSANOW, &portset)==-1) {
error ("MatrixOrbital: tcsetattr(%s) failed: %s", Port, strerror(errno));
return -1;
}
return fd;
}
static void MO_write (char *string, int len)
{
if (Device==-1) return;
if (write (Device, string, len)==-1) {
if (errno==EAGAIN) {
usleep(1000);
if (write (Device, string, len)>=0) return;
}
error ("MatrixOrbital: write(%s) failed: %s", Port, strerror(errno));
}
}
static int MO_contrast (void)
{
char buffer[4];
int contrast;
contrast=atoi(cfg_get("Contrast")?:"160");
snprintf (buffer, 4, "\376P%c", contrast);
MO_write (buffer, 3);
return 0;
}
static void MO_process_bars (void)
{
int row, col;
int i, j;
for (i=2; i<nSegment && Segment[i].used; i++);
for (j=i+1; j<nSegment; j++) {
if (Segment[j].used)
Segment[i++]=Segment[j];
}
nSegment=i;
for (row=0; row<Lcd.rows; row++) {
for (col=0; col<Lcd.cols; col++) {
if (Bar[row][col].type==0) continue;
for (i=0; i<nSegment; i++) {
if (Segment[i].type & Bar[row][col].type &&
Segment[i].len1== Bar[row][col].len1 &&
Segment[i].len2== Bar[row][col].len2) break;
}
if (i==nSegment) {
nSegment++;
Segment[i].len1=Bar[row][col].len1;
Segment[i].len2=Bar[row][col].len2;
Segment[i].type=Bar[row][col].type;
Segment[i].used=0;
Segment[i].ascii=-1;
}
Bar[row][col].segment=i;
}
}
}
static int MO_segment_diff (int i, int j)
{
int RES;
int i1, i2, j1, j2;
if (i==j) return 65535;
if (!(Segment[i].type & Segment[j].type)) return 65535;
if (Segment[i].len1==0 && Segment[j].len1!=0) return 65535;
if (Segment[i].len2==0 && Segment[j].len2!=0) return 65535;
RES=Segment[i].type & BAR_H ? XRES:YRES;
if (Segment[i].len1>=RES && Segment[j].len1<RES) return 65535;
if (Segment[i].len2>=RES && Segment[j].len2<RES) return 65535;
if (Segment[i].len1==Segment[i].len2 && Segment[j].len1!=Segment[j].len2) return 65535;
i1=Segment[i].len1; if (i1>RES) i1=RES;
i2=Segment[i].len2; if (i2>RES) i2=RES;
j1=Segment[j].len1; if (j1>RES) i1=RES;
j2=Segment[j].len2; if (j2>RES) i2=RES;
return (i1-i2)*(i1-i2)+(j1-j2)*(j1-j2);
}
static void MO_compact_bars (void)
{
int i, j, r, c, min;
int pack_i, pack_j;
int pass1=1;
int deviation[nSegment][nSegment];
if (nSegment>CHARS+2) {
for (i=2; i<nSegment; i++) {
for (j=0; j<nSegment; j++) {
deviation[i][j]=MO_segment_diff(i,j);
}
}
while (nSegment>CHARS+2) {
min=65535;
pack_i=-1;
pack_j=-1;
for (i=2; i<nSegment; i++) {
if (pass1 && Segment[i].used) continue;
for (j=0; j<nSegment; j++) {
if (deviation[i][j]<min) {
min=deviation[i][j];
pack_i=i;
pack_j=j;
}
}
}
if (pack_i==-1) {
if (pass1) {
pass1=0;
continue;
} else {
error ("MatrixOrbital: unable to compact bar characters");
nSegment=CHARS;
break;
}
}
nSegment--;
Segment[pack_i]=Segment[nSegment];
for (i=0; i<nSegment; i++) {
deviation[pack_i][i]=deviation[nSegment][i];
deviation[i][pack_i]=deviation[i][nSegment];
}
for (r=0; r<Lcd.rows; r++) {
for (c=0; c<Lcd.cols; c++) {
if (Bar[r][c].segment==pack_i)
Bar[r][c].segment=pack_j;
if (Bar[r][c].segment==nSegment)
Bar[r][c].segment=pack_i;
}
}
}
}
}
static void MO_define_chars (void)
{
int c, i, j;
char buffer[12]="\376N";
for (i=2; i<nSegment; i++) {
if (Segment[i].used) continue;
if (Segment[i].ascii!=-1) continue;
for (c=0; c<CHARS; c++) {
for (j=2; j<nSegment; j++) {
if (Segment[j].ascii==c) break;
}
if (j==nSegment) break;
}
Segment[i].ascii=c;
buffer[2]=c;
switch (Segment[i].type) {
case BAR_L:
for (j=0; j<4; j++) {
char Pixel[] = { 0, 1, 3, 7, 15, 31 };
buffer[j+3]=Pixel[Segment[i].len1];
buffer[j+7]=Pixel[Segment[i].len2];
}
break;
case BAR_R:
for (j=0; j<4; j++) {
char Pixel[] = { 0, 16, 24, 28, 30, 31 };
buffer[j+3]=Pixel[Segment[i].len1];
buffer[j+7]=Pixel[Segment[i].len2];
}
break;
case BAR_U:
for (j=0; j<Segment[i].len1; j++) {
buffer[10-j]=31;
}
for (; j<YRES; j++) {
buffer[10-j]=0;
}
break;
case BAR_D:
for (j=0; j<Segment[i].len1; j++) {
buffer[j+3]=31;
}
for (; j<YRES; j++) {
buffer[j+3]=0;
}
break;
}
MO_write (buffer, 11);
}
}
int MO_clear (void)
{
int row, col;
for (row=0; row<Lcd.rows; row++) {
for (col=0; col<Lcd.cols; col++) {
Txt[row][col]='\t';
Bar[row][col].len1=-1;
Bar[row][col].len2=-1;
Bar[row][col].type=0;
Bar[row][col].segment=-1;
}
}
MO_write ("\014", 1); // Clear Screen
MO_write ("\376V", 2); // GPO off
GPO=0;
return 0;
}
int MO_init (LCD *Self)
{
char *port;
char *speed;
Lcd=*Self;
if (Port) {
free (Port);
Port=NULL;
}
port=cfg_get ("Port");
if (port==NULL || *port=='\0') {
error ("MatrixOrbital: no 'Port' entry in %s", cfg_file());
return -1;
}
Port=strdup(port);
speed=cfg_get("Speed")?:"19200";
switch (atoi(speed)) {
case 1200:
Speed=B1200;
break;
case 2400:
Speed=B2400;
break;
case 9600:
Speed=B9600;
break;
case 19200:
Speed=B19200;
break;
default:
error ("MatrixOrbital: unsupported speed '%s' in %s", speed, cfg_file());
return -1;
}
debug ("using port %s at %d baud", Port, atoi(speed));
Device=MO_open();
if (Device==-1) return -1;
MO_clear();
MO_contrast();
MO_write ("\376B", 3); // backlight on
MO_write ("\376K", 2); // cursor off
MO_write ("\376T", 2); // blink off
MO_write ("\376D", 2); // line wrapping off
MO_write ("\376R", 2); // auto scroll off
return 0;
}
int MO_put (int row, int col, char *text)
{
char *p=&Txt[row][col];
char *t=text;
while (*t && col++<=Lcd.cols) {
*p++=*t++;
}
return 0;
}
int MO_bar (int type, int row, int col, int max, int len1, int len2)
{
int rev=0;
if (len1<1) len1=1;
else if (len1>max) len1=max;
if (len2<1) len2=1;
else if (len2>max) len2=max;
switch (type) {
case BAR_L:
len1=max-len1;
len2=max-len2;
rev=1;
case BAR_R:
while (max>0 && col<=Lcd.cols) {
Bar[row][col].type=type;
Bar[row][col].segment=-1;
if (len1>=XRES) {
Bar[row][col].len1=rev?0:XRES;
len1-=XRES;
} else {
Bar[row][col].len1=rev?XRES-len1:len1;
len1=0;
}
if (len2>=XRES) {
Bar[row][col].len2=rev?0:XRES;
len2-=XRES;
} else {
Bar[row][col].len2=rev?XRES-len2:len2;
len2=0;
}
max-=XRES;
col++;
}
break;
case BAR_U:
len1=max-len1;
len2=max-len2;
rev=1;
case BAR_D:
while (max>0 && row<=Lcd.rows) {
Bar[row][col].type=type;
Bar[row][col].segment=-1;
if (len1>=YRES) {
Bar[row][col].len1=rev?0:YRES;
len1-=YRES;
} else {
Bar[row][col].len1=rev?YRES-len1:len1;
len1=0;
}
if (len2>=YRES) {
Bar[row][col].len2=rev?0:YRES;
len2-=YRES;
} else {
Bar[row][col].len2=rev?YRES-len2:len2;
len2=0;
}
max-=YRES;
row++;
}
break;
}
return 0;
}
int MO_gpo (int num, int val)
{
if (num>=Lcd.gpos)
return -1;
if (val) {
GPO |= 1<<num; // set bit
} else {
GPO &= ~(1<<num); // clear bit
}
return 0;
}
int MO_flush (void)
{
char buffer[256]="\376G";
char *p;
int s, row, col;
MO_process_bars();
MO_compact_bars();
MO_define_chars();
for (s=0; s<nSegment; s++) {
Segment[s].used=0;
}
for (row=0; row<Lcd.rows; row++) {
buffer[3]=row+1;
for (col=0; col<Lcd.cols; col++) {
s=Bar[row][col].segment;
if (s!=-1) {
Segment[s].used=1;
Txt[row][col]=Segment[s].ascii;
}
}
for (col=0; col<Lcd.cols; col++) {
if (Txt[row][col]=='\t') continue;
buffer[2]=col+1;
for (p=buffer+4; col<Lcd.cols; col++, p++) {
if (Txt[row][col]=='\t') break;
*p=Txt[row][col];
}
MO_write (buffer, p-buffer);
}
}
if (GPO & 1) {
MO_write ("\376W", 2); // GPO on
} else {
MO_write ("\376V", 2); // GPO off
}
return 0;
}
int MO_quit (void)
{
debug ("closing port %s", Port);
close (Device);
unlock_port(Port);
return (0);
}
LCD MatrixOrbital[] = {
{ "LCD0821",2, 8,XRES,YRES,BARS,1,MO_init,MO_clear,MO_put,MO_bar,MO_gpo,MO_flush,MO_quit },
{ "LCD1621",2,16,XRES,YRES,BARS,1,MO_init,MO_clear,MO_put,MO_bar,MO_gpo,MO_flush,MO_quit },
{ "LCD2021",2,20,XRES,YRES,BARS,1,MO_init,MO_clear,MO_put,MO_bar,MO_gpo,MO_flush,MO_quit },
{ "LCD2041",4,20,XRES,YRES,BARS,1,MO_init,MO_clear,MO_put,MO_bar,MO_gpo,MO_flush,MO_quit },
{ "LCD4021",2,40,XRES,YRES,BARS,1,MO_init,MO_clear,MO_put,MO_bar,MO_gpo,MO_flush,MO_quit },
{ NULL }
};
Reference in New Issue View Git Blame Copy Permalink