lcd_mat_lib.c

LCD操作集成库源文件

    LCD_EN = SET; erg_uc = LCD_SFR & 0x0F; LCD_EN = CLEAR;
    erg_uc = erg_uc << 4;
    LCD_EN = SET; erg_uc = erg_uc | (LCD_SFR & 0x0F); LCD_EN = CLEAR;

#elif LCD_DEV == LCD_I2C
//  error:  noch nicht implementiert
#endif
  btRS = btRS_Bak;
  return(erg_uc);
}

//***************************************************************
// Funktionsname uc_ReadData() 
// Version: 1.0    Datum 
// Uebergabeparameter: ucInst
// Beschreibung: 
// Funktion uc_SetInst() erlaubt Ihnen die Register vom HD44780  
// einzeln zu beschreiben. Dabei wird das Steuerbit RS nach dem
// Schreiben einer Instruction in den alten Zustand zurueckge- 
// setzt.                                                      
//***************************************************************
uchar uc_SetInst(uchar ucInst){
  uchar ucError;
  bit btRS_Bak;

  if ((ucInst & 0xFC) == ENTRY) {
    btID = (ucInst & 0x02) >> 1;
   }
  btRS_Bak = btRS;
  btRS = LCD_INST;
  ucError = putchar(ucInst);
  btRS = btRS_Bak;
  return(ucError);
}

//***************************************************************
// Funktionsname v_Busy() 
// Version: 1.0    Datum 
// Uebergabeparameter: keine
// Beschreibung: 
// Funktion v_Busy() wartet ab, bis der HD44780 das busy-Flag zu-
// rueckgesetzt hat.                                          
//***************************************************************
void v_Busy(void) {

#if LCD_DEV == LCD_ADR
  while (*READ_INS & 0x80);
#elif LCD_DEV == LCD_PORT
 bit btTemp;
  LCD_D0 = LCD_D1 = LCD_D2 = LCD_D3 = SET; // Datenport zum lesen freigeben
  LCD_R_W = LCD_READ;  // Instruktionen sollen vom HD44780 gelesen werdn
   LCD_RS = LCD_INST;
  do {
    LCD_EN = SET; btTemp = LCD_D3; LCD_EN = CLEAR;
    LCD_EN = SET; LCD_EN = CLEAR;
  } while (btTemp == SET);  // btLF wird als Zwischenspeicher missbraucht

#elif LCD_DEV == LCD_I2C
  v_Wait(5);
#elif LCD_DEV == LCD_PIO
  stPIO.ucControl = PORT_A_IN | PORT_CH_OUT;
  stPIO.ucControl = LCD_PIO_RW | SET_BIT_8255;
  {
  bit btBusy;
  do{
    stPIO.ucControl = LCD_PIO_EN | SET_BIT_8255;
	 btBusy = stPIO.LCD_PIO_PORT.ucRead & LCD_BUSY;
    stPIO.ucControl = LCD_PIO_EN | CLR_BIT_8255;
  }
  while (btBusy); 
  }
  stPIO.ucControl = LCD_PIO_RW | CLR_BIT_8255;
  stPIO.ucControl = PORT_A_OUT | PORT_CH_OUT;
#endif
}

//***************************************************************
// Funktionsname uc_Clrscr() 
// Version: 1.0    Datum 
// Uebergabeparameter: keine
// Beschreibung: 
// Die Funktion uc_Clrscr() loescht den Inhalt vom DD-RAM und setzt
// den Cursor in die linke obere Ecke vom Display.              
//***************************************************************
uchar uc_Clrscr(void) {
  uchar ucError = OK;
  btRS_Old = btRS;
  btRS =LCD_INST;
  ucError = putchar( CLS );                // LCD loeschen 
#if LCD_DEV == LCD_I2C
  v_Wait(100);
#endif
  if (ucError == OK)
   ucError = putchar( HOME );
#if LCD_DEV == LCD_I2C
  v_Wait(100);
#endif
  btRS = btRS_Old;
  ucDD_Adr = 0;  // Bei Home wird der interne DD-Zeiger auf 0 
  return(ucError);
}

//***************************************************************
// Funktionsname putchar() 
// Version: 1.0    Datum 
// Uebergabeparameter: ucValue
// Beschreibung: 
// Die Funktion printf() verwendet zur Ausgabe von Zeichen     
// die Funktion putchar(). Diese ist als Source beim Kauf vom  
// C51-Compiler im PATH \inc vorhanden. Da die Funktion putchar
// nur einen Parameter uebergeben kann, werden Instruktionen mit
// Ausnahme von \n(Zeilenumbruch) separat durchgefuehrt.        
//***************************************************************
char putchar (uchar ucValue)  {

   if (ucValue == 0x0A && !btCG_Set && (btRS == LCD_DATA)) {   // \n wird von printf in 0x0A 
      btLF = ON; btRS = LCD_INST;                      // umgesetzt
   }
   else {
//***************************************************************
// Die Ausgabe erfolgt ueber eine Adresse im XRAM
//***************************************************************
#if LCD_DEV == LCD_ADR
     if (btLF == ON) {
       btRS = LCD_INST;
       ucDD_Adr = ucValue;
       ucValue = SET_DD_RAM | ucValue;
     }
     else if (btRS == LCD_DATA && btLF == OFF) {
       if (btCG_Set == OFF) // Daten werden in CG-RAM uebertragen
        if (btID) ucDD_Adr++; // Display im INCREMENT-Modus
        else ucDD_Adr--;
         *WRITE_DATA = ucValue; *WRITE_DATA = ucValue; }
       else if (btLF) { *WRITE_INS = SET_DD_RAM | ucValue;
         *WRITE_INS = SET_DD_RAM | ucValue; 
         ucDD_Adr = ucValue;
       }
       else { 
	     *WRITE_INS = ucValue; 
		 *WRITE_INS = ucValue;
	   }

//***************************************************************
// Die Ausgabe erfolgt ueber den LCD-Port
//***************************************************************
#elif LCD_DEV == LCD_PORT
     if (btLF == ON) {
       btRS = LCD_INST;
       ucDD_Adr = ucValue;
       ucValue = SET_DD_RAM | ucValue;
     }
     else if (btRS == LCD_DATA && btCG_Set == OFF) {
      if (btID) ucDD_Adr++; // Display im Increment-Modus
      else ucDD_Adr--;
     }
     sbR_W = LCD_WRITE;
 #if (LCD_NIBBLE == LOW_NIBBLE) 
     ucPort = (ucPort & 0xF0) | (ucValue >> 4);   // !! Nur gueltig wenn Datenport Px^0-Px^3
 #else
     ucPort = (ucPort & 0x0F) | (ucValue & 0xF0); // !! Nur gueltig wenn Datenport Px^4-Px^7
 #endif
     EN_CLK;
 #if (LCD_NIBBLE == LOW_NIBBLE) 
     ucPort = (ucPort & 0xF0) | (ucValue & 0x0F); // !! Nur gueltig wenn Datenport Px^0-Px^3 
 #else
     ucPort = (ucPort & 0x0F) | (ucValue << 4);    // !! Nur gueltig wenn Datenport Px^4-Px^7 
 #endif
     EN_CLK;

//***************************************************************
// Die Ausgabe erfolgt ueber den I睠-Bus
//***************************************************************
#elif LCD_DEV == LCD_I2C
     if (btLF == ON) {
       btRS = LCD_INST;
       ucDD_Adr = ucValue;
       ucValue = SET_DD_RAM | ucValue;
     }
     else if (btRS == LCD_DATA && btCG_Set == OFF) {
      if (btID) ucDD_Adr++; // Display im Increment-Modus
      else ucDD_Adr--;
     }
     sbR_W = LCD_WRITE;
     sbEN = SET; 
     ucPort = (ucPort & 0xF0) | (ucValue >> 4); // !! Nur gueltig wenn Datenport Px^0-Px^3
     uc_I2C2IO( LCD_I2C_ADR, ucPort);
     sbEN = CLEAR; 
     uc_I2C2IO( LCD_I2C_ADR, ucPort);

     sbEN = SET; 
     ucPort = (ucPort & 0xF0) | (ucValue & 0x0F); // !! Nur gueltig wenn Datenport Px^0-Px^3:     en = HIGH; i2c2io( LCD_I2C_ADR, ucPort);
     uc_I2C2IO( LCD_I2C_ADR, ucPort);
     sbEN = CLEAR; 
     uc_I2C2IO( LCD_I2C_ADR, ucPort);

//***************************************************************
// Die Ausgabe erfolgt ueber den PIO
//***************************************************************
#elif LCD_DEV == LCD_PIO
     if (btLF == ON) {
       btRS = LCD_INST;
       ucDD_Adr = ucValue;
       ucValue = SET_DD_RAM | ucValue;
     }
     else if (btRS == LCD_DATA && btLF == OFF) {
       if (btCG_Set == OFF) // Daten werden in CG-RAM uebertragen
         if (btID) ucDD_Adr++; // Display im INCREMENT-Modus
         else ucDD_Adr--;
       stPIO.LCD_PIO_PORT.ucWrite = ucValue; 
       stPIO.ucControl = LCD_PIO_RS | SET_BIT_8255;
       stPIO.ucControl = LCD_PIO_EN | SET_BIT_8255;
       stPIO.ucControl = LCD_PIO_EN | CLR_BIT_8255;
       stPIO.ucControl = LCD_PIO_RS | CLR_BIT_8255;
     }
     if (btLF) { 
	   stPIO.LCD_PIO_PORT.ucWrite = SET_DD_RAM | ucValue;
       stPIO.ucControl = LCD_PIO_EN | SET_BIT_8255;
       stPIO.ucControl = LCD_PIO_EN | CLR_BIT_8255;
       ucDD_Adr = ucValue;
     }
     else { 
	   stPIO.LCD_PIO_PORT.ucWrite = ucValue; 
       stPIO.ucControl = LCD_PIO_EN | SET_BIT_8255;
       stPIO.ucControl = LCD_PIO_EN | CLR_BIT_8255;
	 }
#endif
     v_Busy();               // BUSY-Abfrage 
     if (btLF == ON) { btLF = OFF; btRS = LCD_DATA; }
   }
   
  return(0);
}

//***************************************************************
// Funktionsname v_Wait() 
// Version: 1.0    Datum 
// Uebergabeparameter: uiTime
// Beschreibung: 
// Funktion wait() erzeugt Warteschleifen.                     
// In der Tabelle koennen Sie einige Durchlaufzeiten bei einem 
// SYSTEM_CLK von 12MHz ermitteln.                             
// Uebergabewert   Dauer                                       
//     1           30  祍ec                                    
//    10          150  祍ec                                    
//   100          1,3  msec                                    
//  1000           13  msec                                    
//***************************************************************
void v_Wait(uint uiTime) {                  
  uint uiStep;
  if (uiTime == 0) return;
  for (uiStep=0; uiStep < uiTime; uiStep++);
}