Zur Übersicht - INFO - Neueste 50 Beiträge - Neuer Beitrag - Suchen - FAQ - Zum CC1-Forum - Zum CC-Pro-Forum
Re: Init LCD in lcdext vs. pcflcd Kategorie: Sonstige Hardware (von Rolf - 23.08.2003 0:43)
Als Antwort auf Re: Init LCD in lcdext vs. pcflcd von Rolf - 22.08.2003 23:02

Hallo André
übrigens hat das pcflcd-Modul bei mehreren Displays gewaltige Probleme mit der Beleuchtungssteuerung...
Entweder alle aus oder alle an...
Ich hab jetzt so viel am pcflcd verändert, das es sich wirklich lohnt, es mal komplett zu posten.
Evtl. kannst Du dich ja entschlieÃ?en, es als Update zu posten. Es ist ca. ein halbes KB im Runtimecode
kürzer als das ursprüngliche Modul, hat Fixes bezüglich Light, ist voll Multitreadfähig und enthält
schon die neuen Formatfunktionen aus lcdext. Bei allen Funktionen muÃ? die lcd-Nr als erster Parameter
mitgegeben werden, und ich habe die Funktionen auf die tatsächlichen Schreibfunktionen reduziert, so das
anpassungen im Verhalten am i2c-Bus nicht an jeder sondern nur an put und WriteCmd sowie an init
und setlight erfolgen müssen. Das macht das Modul übersichtlicher. Es ist zugegebener Weise etwas
langsamer was aber auch an besserem Timing für das LCD liegt. Für Anwendungen wie ein i2c-Hausbus
hat das aber so oder so kaum Einflu�. Aber wie gesagt, die Probleme bezüglich BF bestehen weiterhin.

GruÃ? Rolf

/******************************************************************/
/* Treiberbibliothek fuer ext. LCD am I²C-Bus im 4-Bit Mode       */
/*    und PCF-LCD-Interface von http://cctools.hs-control.de      */
/* Author    : André Helbig (andre.h@cc2net.de / www.CC2Net.de)   */
/* Versionen : 2.1                                                */
/* Geändert  : 26. Juli 2003                                      */
/* Getestet  : ja                                                 */
/* Benötigt  : i2c.c2 ab V1.2                                     */
/******************************************************************/
/* Ã?nderungen/Neu in V2.1:                                        */
/* - Anpassung auf I²C-Capture                                    */
/* - neue Funktionen zur Ausgabe von Zeit und Datum               */
/******************************************************************/
/* P0= RS                                                         */
/* P1= R/W                                                        */
/* P2= E                                                          */
/* P3= LCD-light                                                  */
/* P4-7= Data                                                     */
/******************************************************************/
/* Schreiben eines Steuerbefehls (RS=0 R/W=0)          (0x0)      */
/* Lesen des Status (busy-Flag und AC) (RS=0, R/W=1)   (0x2)      */
/* Schreiben eines Zeichens zur Anzeige  (RS=1 R/W=1)  (0x3)      */
/* Datenübergabe ist Wechsel zwischen E=1 zu E=0       (0x4)      */
/******************************************************************/
byte light[15];

const Line[]= 0x80,0x80,0xC0,0x94,0xD4; // für 4x20 & zweizeilige LCD
const CharsperLine=16;                  // für 4x20 & zweizeilige LCD
//const Line[]= 0x80,0x80,0xC0,0x90,0xD0; // für 4x16 LCD
//const CharsperLine=16;                  // für 4x16 LCD

/*************************************/
/* LCD-Beleuchtung ein/ausschalten   */
/*************************************/
function setlight(byte pcfnr,byte state)
{
 if pcfnr > 7 i2c.cstart(((pcfnr+16) shl 1)or 64);
 else i2c.cstart((pcfnr shl 1) or 64);
 light[pcfnr]= (state!=0) and 8;
 i2c.write(light[pcfnr]);
 i2c.stop();
}

/*************************************/
/* Kommando-Byte an LCD senden       */
/* Mode: Kommando-Mode (RS=RW=Low)   */
/*************************************/
function WriteCmd (byte pcfnr, byte cmd)
{
 if pcfnr > 7 i2c.cstart(((pcfnr+16) shl 1)or 64);
 else i2c.cstart((pcfnr shl 1) or 64);
 i2c.write((cmd and 0xF0) or light[pcfnr]);
 i2c.write((cmd and 0xF0) or light[pcfnr] or 0x4);// HighNibble
 i2c.write((cmd and 0xF0) or light[pcfnr]);
 i2c.write((cmd shl 4) or light[pcfnr] or 0x4);   // LowNibble
 i2c.write((cmd shl 4) or light[pcfnr]);
 i2c.write(light[pcfnr] or 0x1);
 i2c.stop();
 sleep 2;
}

/*************************************/
/* Schreibt ein Zeichen              */
/* auf das LCD DDRAM (RS=1 RW=Low)   */
/*************************************/
function put(byte pcfnr,byte char)
{
 if pcfnr > 7 i2c.cstart(((pcfnr+16) shl 1)or 64);
 else i2c.cstart((pcfnr shl 1) or 64);
 i2c.write((char and 0xF0) or light[pcfnr] or 0x5);// HighNibble
 i2c.write((char and 0xF0) or light[pcfnr] or 0x1);
 i2c.write((char shl 4) or light[pcfnr] or 0x5);   // LowNibble
 i2c.write((char shl 4) or light[pcfnr] or 0x1);
 i2c.stop();
}

/*************************************/
/* LCD initialisieren                */
/*************************************/
function init (byte pcfnr)
{
byte PCF;
 light[pcfnr]=light[pcfnr] and 8;
 if pcfnr > 7 PCF=((pcfnr+16) shl 1)or 64; else PCF=(pcfnr shl 1) or 64;
 i2c.cstart(PCF);
 i2c.write(0x30 or light[pcfnr]); // E -> Datenübername
 i2c.write(0x34 or light[pcfnr]); // Function Set 8 Bit
 i2c.write(0x30 or light[pcfnr]); // E -> Datenübername
 i2c.stop();
 sleep 15;
 i2c.cstart(PCF);
 i2c.write(0x34 or light[pcfnr]); // Function Set 8 Bit
 i2c.write(0x30 or light[pcfnr]); // E -> Datenübername
 i2c.stop();
 sleep 15;
 i2c.cstart(PCF);
 i2c.write(0x34 or light[pcfnr]); // Function Set 8 Bit
 i2c.write(0x30 or light[pcfnr]); // E -> Datenübername
 i2c.stop();
 sleep 15;
 i2c.cstart(PCF);
 i2c.write(0x24 or light[pcfnr]); // Function Set 4 Bit
 i2c.write(0x20 or light[pcfnr]); // E -> Datenübername
 i2c.stop();
 sleep 5;
 WriteCmd (pcfnr,0b00101000); //Function set 4 Bit, 2 Zeilen, 5x7Dots,
 WriteCmd (pcfnr,0b00001100); //Display On/Off control, Cursor Off, Display on,
 WriteCmd (pcfnr,0b00000001); //Display Clear
 WriteCmd (pcfnr,0b00000110); //Entry mode set,Auto increment, Cursor-Shift
 WriteCmd (pcfnr,0b00000010); //Set DDRAM Pointer 0
}

/*************************************/
/* Zeichen definieren                */
/* addr= 0 bis 7 (ASCII 0-7)         */
/* Daten in Bytearray 8 Byte         */
/* Zeilendaten(5Bit) in Bit4 bis Bit0*/
/* Byte 0 bis 7 = Zeile 0 bis 7      */
/*************************************/
function defineChar(byte pcfnr,byte addr, byte char[])
{byte i;
 addr=(addr and 0x7) shl 3;
 WriteCmd (pcfnr,0x06);
 WriteCmd(pcfnr,0x40 or addr);
 for i=0 ... 7  put(pcfnr,char[i]);
 WriteCmd (pcfnr,0x80);
}

/*************************************/
/* Display löschen                   */
/*************************************/
function clear(byte pcfnr)
{
WriteCmd(pcfnr,0x01);
}

/*************************************/
/* Cursor Home                       */
/*************************************/
function home(byte pcfnr)
{
 WriteCmd(pcfnr,0x02);
}

/***********************************/
/* Cursor setzen                   */
/* Zeile 1 bis 4                   */
/***********************************/
function line(byte pcfnr,byte linenr)// 1 bis 4
{
 WriteCmd(pcfnr,Line[linenr]);
}

/***********************************/
/* Zeile löschen                   */
/***********************************/
function delline(byte pcfnr,byte linenr)
{
byte i;
 line(pcfnr,linenr);
 for i=0...CharsperLine-1 put(pcfnr,0x20);
}

/***********************************/
/* Cursor setzen                   */
/* Zeile 1 bis 4, Spalte 0 - 19(15)*/
/***********************************/
function goto(byte pcfnr,byte line, byte col)
{
 WriteCmd(pcfnr,Line[line]+col);
}

/***********************************/
/* Cursor links schieben           */
/***********************************/
function cursorleft(byte pcfnr)
{
 WriteCmd (pcfnr,0x10);
}

/***********************************/
/* Cursor rechts schieben          */
/***********************************/
function cursorright(byte pcfnr)
{
 WriteCmd (pcfnr,0x14);
}

/***********************************/
/* Cursor-Einstellungen            */
/* 0= aus, 2= Unterstrich,         */
/* 3= Block, blinkend              */
/***********************************/
function setcursor(byte pcfnr,byte cursor)
{
  WriteCmd(pcfnr,(cursor and 0x3) or 0x0C);
}

/*************************************/
/* Ausgabe einer Stringvariable      */
/* auf das LCD                       */
/*************************************/
function print2(byte pcfnr,byte s[])
{
 byte i;
 for i=0 ... s[31]-1 put(pcfnr,s[i]);
}

/*************************************/
/* Ausgabe eines Strings             */
/* auf das LCD                       */
/*************************************/
function print(byte pcfnr,string s)
{
 print2(pcfnr,s);
}

/*************************************/
/* Ausgabe einer Stringvariable      */
/* oder eines Bytearrays auf das LCD */
/*************************************/
function printlength(byte pcfnr,byte s[], byte len)
{
 byte i;
 for i=0 ... len-1 put(pcfnr,s[i]);
}

/*************************************/
/* Einzelziffer                      */
/*************************************/
function ziff(byte pcfnr,byte num)
{
 put(pcfnr,0x30 or (num % 10));
}

/*************************************/
/* 2-stellige Zahl ausgaben          */
/*************************************/
function zahl2(byte pcfnr,int num)
{
  if num>9 ziff(pcfnr,num / 10); else put(pcfnr,0x20);
  ziff(pcfnr,num);
}
/*************************************/
/* 3-stellige Zahl ausgaben(positiv) */
/*************************************/
function zahl3p(byte pcfnr,int num)
{
  if num>99 ziff(pcfnr,num / 100); else put(pcfnr,0x20);
  if num>9  ziff(pcfnr,num /  10); else put(pcfnr,0x20);
  ziff(pcfnr,num);
}

/*************************************/
/* 3-stellige Zahl ausgaben(pos+neg) */
/* -99 bis 999                       */
/*************************************/
function zahl3(byte pcfnr,int num)
{
  if num>99 ziff(pcfnr,num / 100);
   else if num & 0x8000
     {put(pcfnr,0x2D);num=num*(-1);}
     else put(pcfnr,0x20);
  if num>9  ziff(pcfnr,num / 10); else put(pcfnr,0x20);
  ziff(pcfnr,num);
}

/*************************************/
/* 4-stellige Zahl ausgaben(positiv) */
/*************************************/
function zahl4p(byte pcfnr,int num)
{
  if num>999 ziff(pcfnr,num / 1000); else put(pcfnr,0x20);
  if num> 99 ziff(pcfnr,num /  100); else put(pcfnr,0x20);
  if num>  9 ziff(pcfnr,num /   10); else put(pcfnr,0x20);
  ziff(pcfnr,num);
}

/*************************************/
/* 4-stellige Zahl ausgaben(pos+neg) */
/* -999 bis 9999                     */
/*************************************/
function zahl4(byte pcfnr,int num)
{
  if num>999 ziff(pcfnr,num / 1000);
   else if num & 0x8000
     {put(pcfnr,0x2D);num=num*(-1);}
     else put(pcfnr,0x20);
  if num>99 ziff(pcfnr,num / 100); else put(pcfnr,0x20);
  if num> 9 ziff(pcfnr,num /  10); else put(pcfnr,0x20);
  ziff(pcfnr,num);
}

/*************************************/
/* 5-stellige Zahl ausgaben(positiv) */
/* 0 bis 32767                       */
/*************************************/
function zahl5(byte pcfnr,int num)
{
  if num>9999 ziff(pcfnr,num /10000); else put(pcfnr,0x20);
  if num> 999 ziff(pcfnr,num / 1000); else put(pcfnr,0x20);
  if num>  99 ziff(pcfnr,num /  100); else put(pcfnr,0x20);
  if num>   9 ziff(pcfnr,num /   10); else put(pcfnr,0x20);
  ziff(pcfnr,num);
}

/*************************************/
/* Integer-Zahl ausgaben(pos+neg)    */
/* 6-stellig ! -32768 bis _32767     */
/*************************************/
function zahl(byte pcfnr,int num)
{
  if num & 0x8000 {put(pcfnr,0x2D);num=num*(-1);/*num=32768 - num & 0x7FFF;*/}
    else put(pcfnr,0x20);
  zahl5(pcfnr,num);
}
/*************************************/
/* formatierte Zahlausgaben          */
/* Format: ##0,0 (-99,9 - 999,9)     */
/* -999 - 9999 entspr. -99,9 - 999,9 */
/*************************************/
function zahl4n1(byte pcfnr,int num)
{
  if num>999 ziff(pcfnr,num / 1000);
   else if num & 0x8000
     {put(pcfnr,0x2D);num=num*(-1);}
     else put(pcfnr,0x20);
  if num>99 ziff(pcfnr,num / 100); else put(pcfnr,0x20);
  ziff(pcfnr,num / 10);
  put (pcfnr,0x2C);
  ziff(pcfnr,num);
}

/*************************************/
/* formatierte Zahlausgaben          */
/* Format: #0,00 (-9,99 - 99,99)     */
/* -999 - 9999 entspr. -9,99 - 99,99 */
/*************************************/
function zahl4n2(byte pcfnr,int num)
{
  if num>999 ziff(pcfnr,num / 1000);
   else if num & 0x8000
     {put(pcfnr,0x2D);num=num*(-1);}
     else put(pcfnr,0x20);
  ziff(pcfnr,num / 100);
  put(pcfnr,0x2C);
  ziff(pcfnr,num / 10);
  ziff(pcfnr,num);
}

/*************************************/
/* formatierte Zahlausgaben          */
/* Format: ###0,0 (-999,9 - 3276,7)  */
/* -9999 - 32767 ^= -999,9 - 3276,7  */
/*************************************/
function zahl5n1(byte pcfnr,int num)
{
  if num>9999 ziff(pcfnr,num /10000);
   else if num & 0x8000
     {put(pcfnr,0x2D);num=(not num) + 1;}
     else put(pcfnr,0x20);
  if num>999 ziff(pcfnr,num / 1000); else put(pcfnr,0x20);
  if num> 99 ziff(pcfnr,num /  100); else put(pcfnr,0x20);
  ziff(pcfnr,num / 10);
  put(pcfnr,0x2C);
  ziff(pcfnr,num);
}

/*************************************/
/* formatierte Zahlausgaben          */
/* Format: ###0,0 (-99,99 - 327,67)  */
/* -9999 - 32767 ^= -99,99 - 327,67  */
/*************************************/
function zahl5n2(byte pcfnr,int num)
{
  if num>9999 ziff(pcfnr,num /10000);
   else if num & 0x8000
     {put(pcfnr,0x2D);num=num*(-1);}
     else put(pcfnr,0x20);
  if num>999 ziff(pcfnr,num / 1000); else put(pcfnr,0x20);
  ziff(pcfnr,num / 100);
  put(pcfnr,0x2C);
  ziff(pcfnr,num /  10);
  ziff(pcfnr,num);
}

/*************************************/
/* Datums-/Zeitausgaben              */
/*************************************/

/*************************************/
/* Uhrzeit ausgeben                  */
/*************************************/
function time(byte pcfnr,byte format)//0= h:m:s, 1= hh:mm:ss, 2= h:m, 3= hh:mm
{ byte x;
  x=system.hour();
  if format and 1
     ziff(pcfnr,x/10);
    else
     if x>9 ziff(pcfnr,x/10); else put(pcfnr,0x20);
  ziff(pcfnr,x);
  put(pcfnr,':');
  x=system.minute();
  if format and 1
     ziff(pcfnr,x/10);
    else
     if x>9 ziff(pcfnr,x/10); else put(pcfnr,0x20);
  ziff(pcfnr,x);
  if (format and 2)==0
   {
    put(pcfnr,':');
    x=system.second();
    if format and 1
       ziff(pcfnr,x/10);
      else
       if x>9 ziff(pcfnr,x/10); else put(pcfnr,0x20);
    ziff(pcfnr,x);
   }
}

/*************************************/
/* Datum ausgeben                    */
/*************************************/
function date(byte pcfnr,byte format)
//0= d.m.yyyy, 1= dd.mm.yyyy 2= d.m., 3= dd.mm., 4= d.m.yy, 5= dd.mm.yy
{ int x;
  x=system.day();
  if format and 1
     ziff(pcfnr,x/10);
    else
     if x>9 ziff(pcfnr,x/10); else put(pcfnr,0x20);
  ziff(pcfnr,x % 10 + 0x30);
  put(pcfnr,'.');
  x=system.month();
  if format and 1
     ziff(pcfnr,x/10);
    else
     if x>9 ziff(pcfnr,x/10); else put(pcfnr,0x20);
  ziff(pcfnr,x);
  put(pcfnr,'.');
  if (format and 2)==0
   {
    x=system.year();
    if (format and 4)==0
     {
      ziff(pcfnr,x/1000);
      ziff(pcfnr,x/ 100);
     }
    ziff(pcfnr,x / 10);
    ziff(pcfnr,x);
   }
}

/*************************************/
/* Sonderfunktionen                  */
/*************************************/

/*************************************/
/* Definition der Sonderzeichen      */
/* für Bargraph                      */
/* (Belegt ASCII 0 bis 3)            */
/*************************************/
function def_bargraph(byte pcfnr)
{byte chars[8],i,j;
 for i=0 ... 3
 {
  for j=0 ... 7 chars[j]=0b11110000 shr i;
  defineChar(pcfnr,i,chars);
 }
}

/*************************************/
/* Bargraph ausgeben                 */
/* 5 Balken pro Zeichen              */
/*************************************/
function bargraph(byte pcfnr,byte len, byte maxlen)
{byte i,j;
 if len>maxlen len=maxlen;
 for i=0 ... len-1 step 5
 {
  j=len-i;
  if j>4 j=0xFF; else if j j=j-1; else j=0x20;
  put(pcfnr,j);
 }
 while i<maxlen
 {
  put(pcfnr,0x20);
  i=i+5;
 }
}

/*************************************/
/* Definition eines Sanduhrsymbols   */
/* ascii= ASCII-Code 0 bis 7         */
/*************************************/
function def_sanduhr(byte pcfnr,byte ascii)
{byte chars[8];
 chars[0]=0x1F;
 chars[1]=0x11;
 chars[2]=0x0A;
 chars[3]=0x04;
 chars[4]=0x0A;
 chars[5]=0x11;
 chars[6]=0x1F;
 chars[7]=0x00;
 defineChar(pcfnr,ascii,chars);
}

/*************************************/
/* Definition Pfeil-oben             */
/* ascii= ASCII-Code 0 bis 7         */
/*************************************/
function def_arr_up(byte pcfnr,byte ascii)
{byte chars[8];
 chars[0]=0x04;
 chars[1]=0x0E;
 chars[2]=0x15;
 chars[3]=0x04;
 chars[4]=0x04;
 chars[5]=0x04;
 chars[6]=0x04;
 chars[7]=0x00;
 defineChar(pcfnr,ascii,chars);
}

/*************************************/
/* Definition Pfeil-unten            */
/* ascii= ASCII-Code 0 bis 7         */
/*************************************/
function def_arr_down(byte pcfnr,byte ascii)
{byte chars[8];
 chars[0]=0x04;
 chars[1]=0x04;
 chars[2]=0x04;
 chars[3]=0x04;
 chars[4]=0x15;
 chars[5]=0x0E;
 chars[6]=0x04;
 chars[7]=0x00;
 defineChar(pcfnr,ascii,chars);
}


    Antwort schreiben

Antworten: