-
        

Seite 1 von 3 123 LetzteLetzte
Ergebnis 1 bis 10 von 24

Thema: Tabelle (Zeichensatz) auslesen?

  1. #1
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    29.10.2004
    Ort
    GRAZ
    Alter
    51
    Beiträge
    576

    Tabelle (Zeichensatz) auslesen?

    Anzeige

    Hallo

    // Anfängeralarm

    Ich möchte aus einem Datensatz, Werte auslesen, um damit ein Zeichen auf einem Grafik LCD darzustellen.

    Ich habe dazu so eine Tabelle wie hier:
    Code:
    /**********************************************************************************************************
    
    	The LCDlh155 library
    
    	lcd1font.c
    	LCD1 font & routines for LCD displays
    	Characters 32 - 255
    	
    	by Michael Beigl, TecO, Universty of Karlsruhe
     	see the licence.txt
    	
    	History:
    	Start				Michael Beigl	9.12.2000
    
    
    	Preconditions:
    		Include Files Used:	
    			lcdlh155.c 
    
    		Predefined Variables:	LCD_x_global,LCD_y_global
    
    		Predefined Constants:	-
    	
    		Predefined #defines:	-
    
    
    	Postconditions:
    		Variables Defined:
    			struct _FONT_char {byte b[8];};
    			struct _FONT_char CONST _LCD1_1_FONT[32] .. struct _FONT_char CONST _LCD1_7_FONT[32]
    
    		Procedures defined:
    			void LCD_putc(char c)
    		#defines
    
    *********************************************************************************************************/
    
    #ifndef _lcd1font_
    #define _lcd1font_
    
    #include "lcdlh155.c"
    
    
    struct _FONT_char {byte b[8];};
    
    
    struct _FONT_char CONST _LCD1_1_FONT[32]  =                     /* the default 8x8 font 
    								a mix of Times and Souvenier 	
    							      named LCD1*/
    {
      
          { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },	// char 32: space
          { 0x18, 0x3C, 0x3C, 0x18, 0x18, 0x00, 0x18, 0x00 },
          { 0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00 },
          { 0x6C, 0x6C, 0xFE, 0x6C, 0xFE, 0x6C, 0x6C, 0x00 },
          { 0x18, 0x7E, 0xC0, 0x7C, 0x06, 0xFC, 0x18, 0x00 },
          { 0x00, 0xC6, 0xCC, 0x18, 0x30, 0x66, 0xC6, 0x00 },
          { 0x38, 0x6C, 0x38, 0x76, 0xDC, 0xCC, 0x76, 0x00 },
          { 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00 },
          { 0x18, 0x30, 0x60, 0x60, 0x60, 0x30, 0x18, 0x00 },
          { 0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00 },
          { 0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00 },
          { 0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00 },
          { 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30 },
          { 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00 },
          { 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00 },
          { 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0x80, 0x00 },
          { 0x7C, 0xCE, 0xDE, 0xF6, 0xE6, 0xC6, 0x7C, 0x00 },
          { 0x30, 0x70, 0x30, 0x30, 0x30, 0x30, 0xFC, 0x00 },
          { 0x78, 0xCC, 0x0C, 0x38, 0x60, 0xCC, 0xFC, 0x00 },
          { 0x78, 0xCC, 0x0C, 0x38, 0x0C, 0xCC, 0x78, 0x00 },
          { 0x1C, 0x3C, 0x6C, 0xCC, 0xFE, 0x0C, 0x1E, 0x00 },
          { 0xFC, 0xC0, 0xF8, 0x0C, 0x0C, 0xCC, 0x78, 0x00 },
          { 0x38, 0x60, 0xC0, 0xF8, 0xCC, 0xCC, 0x78, 0x00 },
          { 0xFC, 0xCC, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x00 },
          { 0x78, 0xCC, 0xCC, 0x78, 0xCC, 0xCC, 0x78, 0x00 },
          { 0x78, 0xCC, 0xCC, 0x7C, 0x0C, 0x18, 0x70, 0x00 },
          { 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x00 },
          { 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x30 },
          { 0x18, 0x30, 0x60, 0xC0, 0x60, 0x30, 0x18, 0x00 },
          { 0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x00 },
          { 0x60, 0x30, 0x18, 0x0C, 0x18, 0x30, 0x60, 0x00 },
          { 0x3C, 0x66, 0x0C, 0x18, 0x18, 0x00, 0x18, 0x00 },
    };
    
    struct _FONT_char CONST _LCD1_2_FONT[32] =
    {
          { 0x7C, 0xC6, 0xDE, 0xDE, 0xDC, 0xC0, 0x7C, 0x00 },
          { 0x30, 0x78, 0xCC, 0xCC, 0xFC, 0xCC, 0xCC, 0x00 },
          { 0xFC, 0x66, 0x66, 0x7C, 0x66, 0x66, 0xFC, 0x00 },
          { 0x3C, 0x66, 0xC0, 0xC0, 0xC0, 0x66, 0x3C, 0x00 },
          { 0xF8, 0x6C, 0x66, 0x66, 0x66, 0x6C, 0xF8, 0x00 },
          { 0xFE, 0x62, 0x68, 0x78, 0x68, 0x62, 0xFE, 0x00 },
          { 0xFE, 0x62, 0x68, 0x78, 0x68, 0x60, 0xF0, 0x00 },
          { 0x3C, 0x66, 0xC0, 0xC0, 0xCE, 0x66, 0x3A, 0x00 },
          { 0xCC, 0xCC, 0xCC, 0xFC, 0xCC, 0xCC, 0xCC, 0x00 },
          { 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00 },
          { 0x1E, 0x0C, 0x0C, 0x0C, 0xCC, 0xCC, 0x78, 0x00 },
          { 0xE6, 0x66, 0x6C, 0x78, 0x6C, 0x66, 0xE6, 0x00 },
          { 0xF0, 0x60, 0x60, 0x60, 0x62, 0x66, 0xFE, 0x00 },
          { 0xC6, 0xEE, 0xFE, 0xFE, 0xD6, 0xC6, 0xC6, 0x00 },
          { 0xC6, 0xE6, 0xF6, 0xDE, 0xCE, 0xC6, 0xC6, 0x00 },
          { 0x38, 0x6C, 0xC6, 0xC6, 0xC6, 0x6C, 0x38, 0x00 },
          { 0xFC, 0x66, 0x66, 0x7C, 0x60, 0x60, 0xF0, 0x00 },
          { 0x7C, 0xC6, 0xC6, 0xC6, 0xD6, 0x7C, 0x0E, 0x00 },
          { 0xFC, 0x66, 0x66, 0x7C, 0x6C, 0x66, 0xE6, 0x00 },
          { 0x7C, 0xC6, 0xE0, 0x78, 0x0E, 0xC6, 0x7C, 0x00 },
          { 0xFC, 0xB4, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00 },
          { 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xFC, 0x00 },
          { 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x78, 0x30, 0x00 },
          { 0xC6, 0xC6, 0xC6, 0xC6, 0xD6, 0xFE, 0x6C, 0x00 },
          { 0xC6, 0xC6, 0x6C, 0x38, 0x6C, 0xC6, 0xC6, 0x00 },
          { 0xCC, 0xCC, 0xCC, 0x78, 0x30, 0x30, 0x78, 0x00 },
          { 0xFE, 0xC6, 0x8C, 0x18, 0x32, 0x66, 0xFE, 0x00 },
          { 0x78, 0x60, 0x60, 0x60, 0x60, 0x60, 0x78, 0x00 },
          { 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x02, 0x00 },
          { 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x00 },
          { 0x10, 0x38, 0x6C, 0xC6, 0x00, 0x00, 0x00, 0x00 },
          { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF },
    };
    
    struct _FONT_char CONST _LCD1_3_FONT[32] =
    {
          { 0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00 },
          { 0x00, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00 },
          { 0xE0, 0x60, 0x60, 0x7C, 0x66, 0x66, 0xDC, 0x00 },
          { 0x00, 0x00, 0x78, 0xCC, 0xC0, 0xCC, 0x78, 0x00 },
          { 0x1C, 0x0C, 0x0C, 0x7C, 0xCC, 0xCC, 0x76, 0x00 },
          { 0x00, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00 },
          { 0x38, 0x6C, 0x64, 0xF0, 0x60, 0x60, 0xF0, 0x00 },
          { 0x00, 0x00, 0x76, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8 },
          { 0xE0, 0x60, 0x6C, 0x76, 0x66, 0x66, 0xE6, 0x00 },
          { 0x30, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00 },
          { 0x0C, 0x00, 0x1C, 0x0C, 0x0C, 0xCC, 0xCC, 0x78 },
          { 0xE0, 0x60, 0x66, 0x6C, 0x78, 0x6C, 0xE6, 0x00 },
          { 0x70, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00 },
          { 0x00, 0x00, 0xCC, 0xFE, 0xFE, 0xD6, 0xD6, 0x00 },
          { 0x00, 0x00, 0xB8, 0xCC, 0xCC, 0xCC, 0xCC, 0x00 },
          { 0x00, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x00 },
          { 0x00, 0x00, 0xDC, 0x66, 0x66, 0x7C, 0x60, 0xF0 },
          { 0x00, 0x00, 0x76, 0xCC, 0xCC, 0x7C, 0x0C, 0x1E },
          { 0x00, 0x00, 0xDC, 0x76, 0x62, 0x60, 0xF0, 0x00 },
          { 0x00, 0x00, 0x7C, 0xC0, 0x70, 0x1C, 0xF8, 0x00 },
          { 0x10, 0x30, 0xFC, 0x30, 0x30, 0x34, 0x18, 0x00 },
          { 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00 },
          { 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0x78, 0x30, 0x00 },
          { 0x00, 0x00, 0xC6, 0xC6, 0xD6, 0xFE, 0x6C, 0x00 },
          { 0x00, 0x00, 0xC6, 0x6C, 0x38, 0x6C, 0xC6, 0x00 },
          { 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8 },
          { 0x00, 0x00, 0xFC, 0x98, 0x30, 0x64, 0xFC, 0x00 },
          { 0x1C, 0x30, 0x30, 0xE0, 0x30, 0x30, 0x1C, 0x00 },
          { 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00 },
          { 0xE0, 0x30, 0x30, 0x1C, 0x30, 0x30, 0xE0, 0x00 },
          { 0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
    };
    
    struct _FONT_char CONST _LCD1_4_FONT[32] =
    {
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
    };
    
    struct _FONT_char CONST _LCD1_5_FONT[32] =
    {
          { 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00 },
          { 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00 },
          { 0x18, 0x18, 0x7E, 0xC0, 0xC0, 0x7E, 0x18, 0x18 },
          { 0x38, 0x6C, 0x64, 0xF0, 0x60, 0xE6, 0xFC, 0x00 },
          { 0x00, 0xC6, 0x7C, 0xC6, 0xC6, 0x7C, 0xC6, 0x00 },
          { 0xCC, 0xCC, 0x78, 0xFC, 0x30, 0xFC, 0x30, 0x30 },
          { 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00 },
          { 0x3E, 0x61, 0x3C, 0x66, 0x66, 0x3C, 0x86, 0x7C },
          { 0x00, 0xC6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
          { 0x7E, 0x81, 0x9D, 0xA1, 0xA1, 0x9D, 0x81, 0x7E },
          { 0x3C, 0x6C, 0x6C, 0x3E, 0x00, 0x7E, 0x00, 0x00 },
          { 0x00, 0x33, 0x66, 0xCC, 0x66, 0x33, 0x00, 0x00 },
          { 0x00, 0x00, 0x00, 0xFC, 0x0C, 0x0C, 0x00, 0x00 },
          { 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00 },
          { 0x7E, 0x81, 0xB9, 0xA5, 0xB9, 0xA5, 0x81, 0x7E },
          { 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
          { 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00 },
          { 0x30, 0x30, 0xFC, 0x30, 0x30, 0x00, 0xFC, 0x00 },
          { 0x70, 0x18, 0x30, 0x60, 0x78, 0x00, 0x00, 0x00 },
          { 0x78, 0x0C, 0x38, 0x0C, 0x78, 0x00, 0x00, 0x00 },
          { 0x0C, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00 },
          { 0x00, 0x00, 0x33, 0x33, 0x66, 0x7E, 0xC0, 0x80 },
          { 0x7F, 0xDB, 0xDB, 0x7B, 0x1B, 0x1B, 0x1B, 0x00 },
          { 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00 },
          { 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x0C, 0x38 },
          { 0x18, 0x38, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00 },
          { 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x7C, 0x00, 0x00 },
          { 0x00, 0xCC, 0x66, 0x33, 0x66, 0xCC, 0x00, 0x00 },
          { 0xC3, 0xC6, 0xCC, 0xDB, 0x37, 0x6F, 0xCF, 0x03 },
          { 0xC3, 0xC6, 0xCC, 0xDE, 0x33, 0x66, 0xCC, 0x0F },
          { 0xE1, 0x32, 0xE4, 0x3A, 0xF6, 0x2A, 0x5F, 0x86 },
          { 0x30, 0x00, 0x30, 0x60, 0xC0, 0xCC, 0x78, 0x00 },
    };
    
    struct _FONT_char CONST _LCD1_6_FONT[32] =
    {
          { 0x18, 0x0C, 0x38, 0x6C, 0xC6, 0xFE, 0xC6, 0x00 },
          { 0x30, 0x60, 0x38, 0x6C, 0xC6, 0xFE, 0xC6, 0x00 },
          { 0x7C, 0x82, 0x38, 0x6C, 0xC6, 0xFE, 0xC6, 0x00 },
          { 0x76, 0xDC, 0x38, 0x6C, 0xC6, 0xFE, 0xC6, 0x00 },
          { 0xC6, 0x00, 0x38, 0x6C, 0xC6, 0xFE, 0xC6, 0x00 },
          { 0x10, 0x28, 0x38, 0x6C, 0xC6, 0xFE, 0xC6, 0x00 },
          { 0x3E, 0x6C, 0xCC, 0xFE, 0xCC, 0xCC, 0xCE, 0x00 },
          { 0x78, 0xCC, 0xC0, 0xCC, 0x78, 0x18, 0x0C, 0x78 },
          { 0x30, 0x18, 0xFE, 0xC0, 0xFC, 0xC0, 0xFE, 0x00 },
          { 0x0C, 0x18, 0xFE, 0xC0, 0xFC, 0xC0, 0xFE, 0x00 },
          { 0x7C, 0x82, 0xFE, 0xC0, 0xFC, 0xC0, 0xFE, 0x00 },
          { 0xC6, 0x00, 0xFE, 0xC0, 0xFC, 0xC0, 0xFE, 0x00 },
          { 0x30, 0x18, 0x3C, 0x18, 0x18, 0x18, 0x3C, 0x00 },
          { 0x0C, 0x18, 0x3C, 0x18, 0x18, 0x18, 0x3C, 0x00 },
          { 0x3C, 0x42, 0x3C, 0x18, 0x18, 0x18, 0x3C, 0x00 },
          { 0x66, 0x00, 0x3C, 0x18, 0x18, 0x18, 0x3C, 0x00 },
          { 0xF8, 0x6C, 0x66, 0xF6, 0x66, 0x6C, 0xF8, 0x00 },
          { 0xFC, 0x00, 0xCC, 0xEC, 0xFC, 0xDC, 0xCC, 0x00 },
          { 0x30, 0x18, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0x00 },
          { 0x18, 0x30, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0x00 },
          { 0x7C, 0x82, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0x00 },
          { 0x76, 0xDC, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0x00 },
          { 0xC6, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0x00 },
          { 0x00, 0xC6, 0x6C, 0x38, 0x6C, 0xC6, 0x00, 0x00 },
          { 0x3A, 0x6C, 0xCE, 0xD6, 0xE6, 0x6C, 0xB8, 0x00 },
          { 0x60, 0x30, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00 },
          { 0x18, 0x30, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00 },
          { 0x7C, 0x82, 0x00, 0xC6, 0xC6, 0xC6, 0x7C, 0x00 },
          { 0xC6, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00 },
          { 0x0C, 0x18, 0x66, 0x66, 0x3C, 0x18, 0x3C, 0x00 },
          { 0xE0, 0x60, 0x7C, 0x66, 0x66, 0x7C, 0x60, 0xF0 },
          { 0x78, 0xCC, 0xCC, 0xD8, 0xCC, 0xC6, 0xCC, 0x00 },
    };
    
    struct _FONT_char CONST _LCD1_7_FONT[32] =
    {
          { 0xE0, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x7E, 0x00 },
          { 0x1C, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x7E, 0x00 },
          { 0x7E, 0xC3, 0x3C, 0x06, 0x3E, 0x66, 0x3F, 0x00 },
          { 0x76, 0xDC, 0x78, 0x0C, 0x7C, 0xCC, 0x7E, 0x00 },
          { 0xCC, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x7E, 0x00 },
          { 0x30, 0x30, 0x78, 0x0C, 0x7C, 0xCC, 0x7E, 0x00 },
          { 0x00, 0x00, 0x7F, 0x0C, 0x7F, 0xCC, 0x7F, 0x00 },
          { 0x00, 0x00, 0x78, 0xC0, 0xC0, 0x78, 0x0C, 0x38 },
          { 0xE0, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00 },
          { 0x1C, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00 },
          { 0x7E, 0xC3, 0x3C, 0x66, 0x7E, 0x60, 0x3C, 0x00 },
          { 0xCC, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00 },
          { 0xE0, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00 },
          { 0x38, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00 },
          { 0x7C, 0xC6, 0x38, 0x18, 0x18, 0x18, 0x3C, 0x00 },
          { 0xCC, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00 },
          { 0x08, 0x3C, 0x08, 0x7C, 0xCC, 0xCC, 0x78, 0x00 },
          { 0x00, 0xF8, 0x00, 0xF8, 0xCC, 0xCC, 0xCC, 0x00 },
          { 0x00, 0xE0, 0x00, 0x78, 0xCC, 0xCC, 0x78, 0x00 },
          { 0x00, 0x1C, 0x00, 0x78, 0xCC, 0xCC, 0x78, 0x00 },
          { 0x78, 0xCC, 0x00, 0x78, 0xCC, 0xCC, 0x78, 0x00 },
          { 0x76, 0xDC, 0x00, 0x78, 0xCC, 0xCC, 0x78, 0x00 },
          { 0x00, 0xCC, 0x00, 0x78, 0xCC, 0xCC, 0x78, 0x00 },
          { 0x30, 0x30, 0x00, 0xFC, 0x00, 0x30, 0x30, 0x00 },
          { 0x00, 0x02, 0x7C, 0xCE, 0xD6, 0xE6, 0x7C, 0x80 },
          { 0x00, 0xE0, 0x00, 0xCC, 0xCC, 0xCC, 0x7E, 0x00 },
          { 0x00, 0x1C, 0x00, 0xCC, 0xCC, 0xCC, 0x7E, 0x00 },
          { 0x78, 0xCC, 0x00, 0xCC, 0xCC, 0xCC, 0x7E, 0x00 },
          { 0x00, 0xCC, 0x00, 0xCC, 0xCC, 0xCC, 0x7E, 0x00 },
          { 0x18, 0x30, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8 },
          { 0xF0, 0x60, 0x7C, 0x66, 0x7C, 0x60, 0xF0, 0x00 },
          { 0x00, 0xCC, 0x00, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8 }
    };
    
    /////////////////////////////////////////////////////////////////////////////////////////////////
    
    
    
    void LCD_putc(char c)
    { byte i,ii,y;
    
      if (c=='\n') 			// line feed
    	{ LCD_x_pos(0); 
    	  if (LCD_y_global+9 < LCD_Y_MAX) LCD_y_pos(LCD_y_global +8);
     	  else LCD_y_pos (0);
    	  return; 
    	}
      if ((c<32)||(c>223)) return;
      ii = (c-32) % 32;
      y = LCD_y_global;
      
     for (i=0; i<8; i++) 
      {
        switch ((c-32)/32) {
    	case 0: LCD_write_byte(_LCD1_1_FONT[ii].b[i],0); break;
    	case 1: LCD_write_byte(_LCD1_2_FONT[ii].b[i],0);break;
    	case 2: LCD_write_byte(_LCD1_3_FONT[ii].b[i],0);break;
    	case 3: LCD_write_byte(_LCD1_4_FONT[ii].b[i],0);break;
    	case 4: LCD_write_byte(_LCD1_5_FONT[ii].b[i],0);break;
    	case 5: LCD_write_byte(_LCD1_6_FONT[ii].b[i],0);break;
    	case 6: LCD_write_byte(_LCD1_7_FONT[ii].b[i],0);break;
    	}
       }
      if (LCD_x_global<LCD_X_MAX) { LCD_y_pos(y); LCD_x_pos(LCD_x_global+1);}
      else {
    	  if (LCD_y_global==0) // right downmost position !
    		{ LCD_pos_0(); }
    	  else // line feed
    		{ LCD_x_pos(0); }
    	}
    }
    
    #endif
    Leider checke ich nicht ganz (Anfänger) wie das da abgerufen wird.
    Habe das ganze schon in Bascom gemacht und da funktioniert es.
    (jetzt will ich es auf C Umschreiben )

    In Bascom springe ich auf die entsprechende Stelle in der Tabelle
    (ergibt sich aus dem ASC-Wert des Zeichens und einen Wert dazu..)
    und lese dann von dort dann acht Werte ein für ein Zeichen.

    Wie kann ich in C aus so eine Tabelle zugreifen ?

    Habe schon das Forum durchgeschaut....
    In einem Tutorial fand ich zum Befehl "struct", dass der eher für eine Zusammenfassung von mehrere Datentypen ist ?!

    Ist der Befehl "struct" dazu gut und wie funktioniert der eigentlich?
    Oder gibt es da noch einen bessern Ansatz?

    Bitte um Hilfe

    l.G. Roberto

  2. #2
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.801
    Die bekommst du so:
    Code:
    _LCD1_1_FONT['!'-' '].b[0] // oberstes Byte des !
    ...
    _LCD1_1_FONT['!'-' '].b[7] // unterstes Byte des !
    ...wobei um ne wirkliche Aussage zu treffen, muss man wissen, wie CONST definiert ist. Wenn das bewirkt, daß die Fonts im Flash landen (zB PROGMEM, was hier sehr sinvoll ist) anstatt im RAM (was den RAM zum platzen bringt) dann musst du die Zugriffe mit pgm_read_byte und Konsorten tun.

    Aber vorher seien dir die BASICs von C (zB struct) ans Herz gelegt...
    Disclaimer: none. Sue me.

  3. #3
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    29.10.2004
    Ort
    GRAZ
    Alter
    51
    Beiträge
    576
    Hallo SprinterSB (Danke für die schnelle Antwort )

    Stehe irgendwie im Wald

    Das "struct" von C-Tutorial habe ich mir durchgelesen..
    Kapiere ich irgendwie nicht ganz und irgendwie will ich ja nur Byte Variablen?!

    Kann ich das nicht irgendwie mit einem Array machen?

    Die Tabelle ist ja bei mir dann durchgehend. (nicht wie in dem Beispiel-Listing)

    Also z.B. 250 Zeilen mit je 8 Byte_werten.


    Ich müsste nur wissen, wie ich diese Tabelle deklarieren kann und wie ich dann auf einen bestimmten Punkt in dieser Tabelle zugreifen kann.

    Wie könnte das funktionieren?

    Braucht man dazu "struct" oder Array's? oder geht das auch einfacher?

    l.G. Roberto

  4. #4
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    29.10.2004
    Ort
    GRAZ
    Alter
    51
    Beiträge
    576
    Hallo

    Habe inzwischen eine Lösung gefunden:

    Deklariere jetzt mit:

    const char Zeichensatz[224][8] =
    {
    {0x00, 0x11, 0x00, 0x22, 0x45, 0xfe, 0x00, 0x45},
    u.s.w.

    };

    und greife zu mit:
    zwei Schleifen für die Zeile und für die 8 Zeichen pro Zeile

    Daten= Zeichensatz [I] [I1];

    Ist das ein guter Ansatz, oder geht es noch besser?

    Das mit Arrays u.s.w. hatte ich schon gesehen, nur das man das dann so mit"=" einfach die Werte angeben kann, wusste ich nicht.

    (Bei Bascom hatte ich das mit "date..." angelegt und mit Lookup geholt.)


    l.G. Roberto

  5. #5
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    29.05.2005
    Beiträge
    1.018
    Hallo Roberto,
    du bist ja schon selbst auf die richtige (eine mögliche) Lösung gekommen.
    Möglicherweise fehlt dir in der C-Umgebung nur erst noch das Verständnis für den Begriff Struktur (nicht mit struct verwechseln).
    Es gibt eigendlich keine Strukturen in C. Du selbst nimmst dir Speicher und organisiert deine Daten auch selber.
    Du hast dir in deinem Fall mit "const char Zeichensatz[224][8]" so einfach mal 244*8 Byte Speicher reserviert. (Im Regelfall Byte, da du den Datentyp char angegeben hast.)
    Organisiert hast du ihn mit den beiden []-Klammern in einer Form, dass du halt 2-dimensional auf den Speicherbereich zugreifen kannst.
    Es hätte auch gereicht mit "const char Zeichensatz[1792]" Speicher zu reservieren und beim Zugriff dann halt "Daten= Zeichensatz [I*224 + I1]" zu nutzen.

    Vielleicht noch dazu:
    In C beginnt die Indizierung IMMER mit 0 in solchen [], und endet immer mit einem Wert kleiner als du beim reservieren angegeben hast.
    Also als letzte Möglichkeit bei dir: Daten=Zeichensatz [223] [7].
    Aber Vorsicht: C verbietet es nicht auch größere Werte in den Klammern anzugeben. Dann landest du halt in einem anderen Speicherbereich. (Meistens ist das fehlerhaft, manchmal sehr tricky)
    Lieber Asuro programieren als arbeiten gehen.

  6. #6
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    29.10.2004
    Ort
    GRAZ
    Alter
    51
    Beiträge
    576
    Hallo Sternhalter (Danke für die Antwort )
    du bist ja schon selbst auf die richtige (eine mögliche) Lösung gekommen.
    Welche Lösungen wären den besser ?

    Könnte man die Deklaration auch mit einer normalen Variablen, statt einer Constante machen ? Vorteile/Nachteile?

    Gemerkt hatte ich bei mir, dass ich die Deklaration am Anfang machen muss.
    (unschön zu lesen)
    Kann ich die Werte auch an das Ende des Codes schreiben und vielleicht mit einer Art Vorwärtsdeklaration machen ?? (Prototypen)

    Oder ist es da sinnvoller, den Zeichencode in ein extra File zu legen und dann zu verlinken? (hatte ich wo so gesehen..)

    l.G. Roberto

  7. #7
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    08.05.2005
    Ort
    Issum
    Alter
    45
    Beiträge
    2.236
    Du hast nicht etwa diese Unmenge an Bytes im Ram geschrieben
    mit const zu deklarieren reicht noch nicht aus un vor allem das auslesen sollte dann mit pgm_read_byte erfolgen
    Vorsicht, der Kompiler erzeugt keine Warnung wenn Ram alle ist !
    Schau mal hier
    Diese Einführung ist recht brauchbar.
    Un es hilft auch kein ständiges vergleichen mit Bascom, es sind zwei ganz andere Welten !
    Kernighan und Ritchie haben ein sehr gutes Buch rausgebracht, sollte man sich vielleicht mal zulegen, wenn man es mit C ernst meint

    Gruß Sebastian
    Software is like s e x: its better when its free.
    Linus Torvald

  8. #8
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    29.05.2005
    Beiträge
    1.018
    Hallo Roberto,
    Stern-"Halter" ist auch nicht schlecht. Trotzdem danke für das danke.

    Zitat Zitat von Roberto
    Welche Lösungen wären den besser ?
    Oh, da ich so seit ca. 25 Jahren mit C rummache, und immer noch nicht die 'richtige Lösung' gefunden habe, gibt es da erst einmal keine Antwort drauf.

    Zitat Zitat von Roberto
    Oder ist es da sinnvoller, den Zeichencode in ein extra File zu legen und dann zu verlinken? (hatte ich wo so gesehen..)
    Das würde schon gehen.
    Die Tabelle in einer eigenen Datei. Z.B.: zeichensatz.h
    Diese Datei im Source mit deinem main() mit: #include "zeichensatz.h" dazuholen. (Vorsicht, darf so nur genau einmal mit #include in eine C-Datei aus dem Projekt geholt werden. Ist auch etwas für ca. 1 Jahr C-rummachen)

    Zu deinen restlichen Fragen ist der Hinweis von izaseba Gold wert.
    Ich hätte noch http://www.schellong.de/c.htm (Schlüsselwörter -> typedef)
    oder eher http://www.c-programme.de/ (Mit Downloadmöglichkeit)
    anzubieten.
    Lieber Asuro programieren als arbeiten gehen.

  9. #9
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    29.10.2004
    Ort
    GRAZ
    Alter
    51
    Beiträge
    576
    Hallo Sternthaler
    Stern-"Halter" ist auch nicht schlecht. Trotzdem danke für das danke.
    Ups , Sorry

    Ich hätte noch http://www.schellong.de/c.htm
    oder eher http://www.c-programme.de/ (Mit Downloadmöglichkeit)
    anzubieten.
    Danke für die Links.. Werde ich mal anschauen.
    Wollte eigentlich gestern eh schon ein Buch für C kaufen, wusste aber nicht, was es da gutes gibt...
    Gibt es eigentlich auch ein Buch für C, dass schon mit einem Mega 8 oder 32 arbeitet?
    Meist sind die Bücher ja für C auf dem PC und da gibt es schon einige Unterschiede wegen Speicher, Aus/Eingabe u.s.w.

    Toll wäre da ein Buch, dass schon Bezug auf den AVR nimmt mit vielleicht Beispielen u.s.w....





    @izaseba
    Eh? Du hast nicht etwa diese Unmenge an Bytes im Ram geschrieben Eh?
    Ehrlich gesagt. keine Anhung
    Wo schreibt er es den hin bei Const char.....?

    mit const zu deklarieren reicht noch nicht aus un vor allem das auslesen sollte dann mit pgm_read_byte erfolgen Eh?
    Muss man das eigentlich mit "Const" machen ?
    Habe das selber nur von einem anderen Code abgekuckt.
    "pgm_read_byte" habe ich noch nie gelesen..
    Was bracuht man da für eine Include-File?

    Vorsicht, der Kompiler erzeugt keine Warnung wenn Ram alle ist !
    Schau mal hier
    Diese Einführung ist recht brauchbar.
    Ja, dass hatte ich schon ausgedruckt und durchgeschaut.
    Da gehts aber eher um die Hardware Seite..
    Unter was sollte ich den da nachschauen?
    Am Anfang erschlagt einem der Umfang von den neuen Befehlen
    (Wusste zuerst auch nicht, ob ich für mein Problem jetzt unter Array, struct oder Zeiger schauen soll....)

    Un es hilft auch kein ständiges vergleichen mit Bascom, es sind zwei ganz andere Welten !
    Schon klar, aber ich habe halt da einen Code in Bascom der da funktioniert und denn will ich als erste Aufgabe, in C mal umschreiben.
    Die Angabe der Befehle in Bascom war eher dazu gedacht, dass man weis was ich mit den Speicherart meinte

  10. #10
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    29.10.2004
    Ort
    GRAZ
    Alter
    51
    Beiträge
    576
    Zu der Frage wegen dem Ram:

    HAbe mal probiert das "const" wegzulassen.
    Dann meldet der Compiler:

    "The Hardware Stack Size has a dangerously low value: -1052 Byte"

    (Mega16)

    Also ich vermute mal, dass das mit dem "const" schon seinen Sinn hat, weil da kommt keine Meldung

Seite 1 von 3 123 LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •