Tabelle (Zeichensatz) auslesen?

**Roberto** · 30.07.2007, 23:08

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

**SprinterSB** · 30.07.2007, 23:27

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...

**Roberto** · 30.07.2007, 23:55

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

**Roberto** · 31.07.2007, 21:36

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

**Sternthaler** · 31.07.2007, 22:08

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)

**Roberto** · 31.07.2007, 22:20

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

**izaseba** · 31.07.2007, 22:31

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

**Sternthaler** · 31.07.2007, 22:47

Hallo Roberto,
Stern-"Halter" ist auch nicht schlecht. Trotzdem danke für das danke.

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 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.

**Roberto** · 31.07.2007, 23:24

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

**Roberto** · 31.07.2007, 23:58

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

Thema: Tabelle (Zeichensatz) auslesen?

Themen-Optionen

Thema durchsuchen

Anzeige

Tabelle (Zeichensatz) auslesen?

Lesezeichen

Lesezeichen

Berechtigungen