Tabelle (Zeichensatz) auslesen?

[Roberto]

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:


/************************************************** ************************************************** ******

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]

Die bekommst du so:


_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]

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]

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]

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]

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]

:-s Du hast nicht etwa diese Unmenge an Bytes im Ram geschrieben :-s
mit const zu deklarieren reicht noch nicht aus un vor allem das auslesen sollte dann mit pgm_read_byte erfolgen :-s
Vorsicht, der Kompiler erzeugt keine Warnung wenn Ram alle ist !
Schau mal hier (http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial)
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]

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


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.


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]

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]

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 :-)

[izaseba]

Klar hat const einen Sinn. Du willst ja auch Deine Arrays im Flash ablegen, Du mußt es aber dem Kompiler so mitteilen:


const uint8_t beispiel PROGMEM = 255;


Willst Du z.B. die Konstante auf ein Port ausgeben mußt Du es mit
pgm_read_byte() auslesen z.B. so


PORTB = pgm_read_byte(&beispiel);

Wichtig ist, daß Du pgm_read_byte einen Zeiger auf die Flashadresse übergibst.
Nachlesen kannst Du es z.B. hier (http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29)

Tja, Buch...
Vergiss es, es gibt kein Buch, das von C und AVR handelt.
Ich kann Dir wirklich das obengenannte Werk "Programmieren in C" von den Vätern der Sprache empfehlen, klar ist es für PC gedacht, es macht aber nichts, die Unterschiede sind nicht so groß.
Dafür gibt es das Tutorial auf www.mikrocontroller.net und die avr libc Doku auf http://www.nongnu.org/avr-libc/user-manual/index.html
Gruß Sebastian
P.S.


Am Anfang erschlagt einem der Umfang von den neuen Befehlen

In C gibt es etwa 30 Befehle, das ist doch nicht viel, oder ;-)



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.
Manchmal kann man Sachen nicht 1:1 übersetzen, man muß halt komplett umdenken.

P.P.S Irgendwo hab ich noch meinen Code für eine Propelleruhr, da hab ich es ähnlich gemacht, muß mal morgen danach gucken, kannst Du Dir als Beispiel anschauen.

[Roberto]

Hallo izaseba

Willst Du z.B. die Konstante auf ein Port ausgeben musst Du es mit
pgm_read_byte() auslesen z.B. so

Eine blöde Frage:
Was passiert, wenn ich es nicht so mache ?

Habe mich jetzt weitergespielt und kann jetzt schon mal den Zeichensatz am LCD ausgeben.
(nur mit Const..... und normalem Zugriff (Datensatz [][] ))
Funktioniert eigentlich soweit :-)
(Compiler= CodeVison)

l.G. Roberto
Ps.:
Habs im Tutorial nachgelesen.
Ganz verstehe ich es zwar noch nicht, aber kann es vielleicht deshalb funktionieren, weil ich keinen AVR-GCC verwende?

[Sternthaler]

Hallo Roberto,
wegen eines Buches zu C und AVR kann auch ich nicht weiterhelfen. Allerdings ist der von izaseba angegebene Link doch eigendlich dann genau richtig um mal einen kompletten Überblick zu erhalten.

Zu deiner Frage: "Was passiert, wenn ich es nicht so mache?":
Als Vermutung kann ich nur annehmen, dass die Funktion pgm_read_byte eben deshalb notwendig ist, da ja schon der Assembler-Befehl nun mal anders ist wenn im RAM bzw. im FLASH Daten gelesen werden sollen. Somit hat da irgendjemand die Funktion pgm_read_byte() geschrieben damit du es leichter hast.

Was izaseba mit den 30 Befehlen von C meint, ist natürlich nur das reine 'Grundgerüst'. Je nachdem wie viele Lib's du dazu holst wächst das was du zur Zeit als Befehl ansieht 'etwas' an. Vielleicht hilft der Begriff Unterfunktion oder Subfunction aus Basic eher um einen Vergleich zu den aus Lib's kommenden 'Befehlen' zu erklären.
Im allgemeinen musst du ein #include in deinen Sourcen aufnehmen. Alle in diesem Include declarierten 'Funktionen' sind z.B. solche Unterfunktionen. Es bleibt also beim "Kernighan und Ritchie" von izaseba.

Beim Compiler ist es fast egal welchen man nimmt, solange der auch Code für die gewünschte 'Zielmaschine' (also ATmega) produzieren kann.

P.S.: Tutorial lesen ist immer gut. Nicht alles verstehen, heißt eigendlich: Ich habe einen Teil verstanden. Das ist Erfolg ;-)

[Roberto]

Danke Euch einstweilen!

Werde das mit dem Const einstweilen so lassen...
Wenns Probleme gibt, kann ich es ja mal mit den Befehlen probieren...
Jetzt brauche ich dann nur mehr einen Befehl wo ich Strings umwandeln kann..
Aber da werde ich eventuell einen anderen Thread aufmachen ;-)


P.S.: Tutorial lesen ist immer gut. Nicht alles verstehen, heißt eigendlich: Ich habe einen Teil verstanden. Das ist Erfolg
Danke für die aufmunterten Worte :-)
Wird schon werden ;-)

Wegen Buch:
Schade das es da nix für den AVR gibt :-k
Dann werde ich derzeit mal nix kaufen.

l.G. Roberto

Ps.:

P.P.S Irgendwo hab ich noch meinen Code für eine Propelleruhr, da hab ich es ähnlich gemacht, muß mal morgen danach gucken, kannst Du Dir als Beispiel anschauen.
Ja, dass wäre sehr nett! \:D/
Da könnte ich auch gleich bei der Stringumwandlung nachschauen O:)
(in Bascom hatte ich das auch schon mal gemacht)

[izaseba]

Funktioniert eigentlich soweit
(Compiler= CodeVison)

=; HALT =;

Hab ich das irgendwo überlesen :-s
Mein Ausführungen beziehen sich auf gcc !
Es kann sein, daß CodeVision es anders macht, vielleicht braucht man hier kein PROGMEM und pgm_read*
Damit ist das Tutorial auch nicht ganz richtig für Dich, das weiß ich aber nicht.
Hmm, da hilft nur probieren, es hat mich auch die Warnung mit Stack gewundert, weil soweit ich weiß gibt gcc keine Warnungen dieser Art, das weiß ich auch nur von lesen im Forum, selber habe ich es noch nicht probiert Ram zu sprengen :-)

Wie dem auch sei, schön das es bei Dir klappt, darf ich fragen, warum Codevision ?
Mußt Du es beruflich einsetzen ?
Ich mein irgendwo muß es einen Vorteil geben, aber viel Hilfe wirst Du damit nicht bekommen(Zumindest nicht hier, vielleicht bei mikrocontroller.net)

Gruß Sebastian

P.S.


Zu deiner Frage: "Was passiert, wenn ich es nicht so mache?":
Als Vermutung kann ich nur annehmen, dass die Funktion pgm_read_byte eben deshalb notwendig ist, da ja schon der Assembler-Befehl nun mal anders ist wenn im RAM bzw. im FLASH Daten gelesen werden sollen. Somit hat da irgendjemand die Funktion pgm_read_byte() geschrieben damit du es leichter hast.

Genau so ist es, C wurde für Maschinen geschrieben, bei denen sich alles in Ram abspielt (Du weißt ja,AVR hat getrennte Daten und Programmräume)

Damit gibt es bei AVR 3 mal gleiche Speicheradressen im Ram,Flash und EEPROM.
Damit der arme Kompiler weißt, woher er die Werte nehmen soll gibt es halt dieses PROGMEM, was einfach nur sagt, diese Konstante soll bitteschön in den Flash, und eben noch pgm_read* um zu sagen, ich möchte aus dem Flash lesen und nicht aus dem Ram.
Wenn man es nicht beachtet gibt es Salat und man sucht ziemlich lange nach dem Fehler.
Genauso ist es mit Zeigern, man muß anders einen Zeiger auf Werte im Flash deklarieren und anders auf Werte im Ram und noch anders auf EEprom.

Ich weiß aber nicht wieweit es bei Codevision wichtig ist! Da mußt Du schon selber in der Doku zu Deinem Kompiler nachschlagen ;-)

[Roberto]

Hallo Izaseba


darf ich fragen, warum Codevision ?
musst Du es beruflich einsetzen ?
Nein eigentlich nicht.

Habe zuerst mal mit dem GCC probiert, aber das mit Make-File war mir ein bisschen zu blöd ](*,)

Dann habe ich einen Tipp für CodeVision bekommen.

Bis jetzt kann ich nichts negatives sagen :-b
Schöne Übersichten über alle Variablen, Funktionen und Include-Files, die man verwendet.
Einen klick für Make und einen Klick zum schreiben in den AVR
und fertig ist die Laube \:D/


Genau so ist es, C wurde für Maschinen geschrieben, bei denen sich alles in Ram abspielt (Du weißt ja,AVR hat getrennte Daten und Programmräume)

Darum wundert es mich auch ein bisschen, dass es da noch keine Bücher gibt. Ein Marktlücke ? ;-)

Ps.:
Findest Du deinen Code für die Propelleruhr noch ?
Würde mich sehr interessieren O:)

l.G. Roberto

[izaseba]

Darum wundert es mich auch ein bisschen, dass es da noch keine Bücher gibt. Ein Marktlücke ?

Vielleicht, vielleicht auch nicht, ich finde die Entwicklung geht ziemlich schnell, das Buch könnte schon veraltet sein, bevor es überhaupt rausgekommen ist :-k


Findest Du deinen Code für die Propelleruhr noch ?
Würde mich sehr interessieren

Ja kein Problem, mein Programme halte ich mehrfach gespeichert ;-)
Ich wollte Teile davon als Beispiel für den Flashzugriff zeigen, da es aber in Codevision wohl doch anders geht ist es unnötig, aber naja, so habe ich das gemacht und zwar zuerst ein 2D Array für Zahlen und Buchstaben, ich wollte nicht die Ganze ASCII Tabelle implementieren sondern nur das wichtigste sie sieht etwa so aus:



/* Alphabet kleine Buchstaben*/
const uint8_t zeichen_k[][5] PROGMEM = {
/*0*/
{ 0x83,0x75,0x6D,0x5D,0x83 },
/*1*/
{ 0xFF,0xBD,0x01,0xFD,0xFF },
/*2*/
{ 0xBD,0x79,0x75,0x6D,0x9D },
/*3*/
{ 0x7B,0x7D,0x5D,0x2D,0x73 },
/*4*/
{ 0xE7,0xD7,0xB7,0x01,0xF7 },
/*5*/
{ 0x1B,0x5D,0x5D,0x5D,0x63 },
/*6*/
{ 0xC3,0xAD,0x6D,0x6D,0xF3 },
/*7*/
{ 0x7F,0x71,0x6F,0x5F,0x3F },
/*8*/
{ 0x93,0x6D,0x6D,0x6D,0x93 },
/*9*/
{ 0x9F,0x6D,0x6D,0x6B,0x87 },
/*a*/
{ 0xFB,0xD5,0xD5,0xD5,0xE1 },
/*b*/
{ 0x01,0xED,0xDD,0xDD,0xE3 },
/*c*/
{ 0xE3,0xDD,0xDD,0xDD,0xFB },
/*d*/
{ 0xE3,0xDD,0xDD,0xED,0x01 },
/*e*/
{ 0xE3,0xD5,0xD5,0xD5,0xE7 },
/*f*/
{ 0xEF,0x81,0x6F,0x7F,0xBF },
/*g*/
{ 0xE7,0xDA,0xDA,0xDA,0xC1 },
/*h*/
{ 0x01,0xEF,0xDF,0xDF,0xE1 },
/*i*/
{ 0xFF,0xDD,0x41,0xFD,0xFF },
/*j*/
{ 0xFD,0xFE,0xDE,0x41,0xFF },
/*k*/
{ 0x01,0xF7,0xEB,0xDD,0xFF },
/*l*/
{ 0xFF,0x7D,0x01,0xFD,0xFF },
/*m*/
{ 0xC1,0xDF,0xE7,0xDF,0xE1 },
/*n*/
{ 0xC1,0xEF,0xDF,0xDF,0xE1 },
/*o*/
{ 0xE3,0xDD,0xDD,0xDD,0xE3 },
/*p*/
{ 0xE0,0xEB,0xEB,0xEB,0xF7 },
/*q*/
{ 0xF7,0xEB,0xEB,0xF3,0xE0 },
/*r*/
{ 0xC1,0xEF,0xDF,0xDF,0xEF },
/*s*/
{ 0xED,0xD5,0xD5,0xD5,0xFB },
/*t*/
{ 0xDF,0x03,0xDD,0xFD,0xFB },
/*u*/
{ 0xC3,0xFD,0xFD,0xFB,0xC1 },
/*v*/
{ 0xC7,0xFB,0xFD,0xFB,0xC7 },
/*w*/
{ 0xC3,0xFD,0xF3,0xFD,0xC3 },
/*x*/
{ 0xDD,0xEB,0xF7,0xEB,0xDD },
/*y*/
{ 0xCF,0xF6,0xF6,0xF6,0xC1 },
/*z*/
{ 0xDD,0xD9,0xD5,0xCD,0xDD },
/*SPACE*/
{ 0xFF,0xFF,0xFF,0xFF,0xFF },
/*:*/
{ 0xFF,0x93,0x93,0xFF,0xFF }

Die Tabelle ist aber Vertikal organisiert (Ist ja eine Propelleruhr, muß also Vertikal eingeblendet werden)
Die Zahlen krieg ich aus einer RTC im gepacktem BCD Format in einer Freien mS werden die Nibbles zerschlagen, womit ich dann die Uhrzeit im normalem binärem Format stehen habe, darum fängt die Null bei zeichen_k[0][] an die 9 steht dann bei [9]
Damit Spare ich mir irgendwelche Umrechnungen ;-)

Es müssen noch Monate und Wochentage implementiert werden, da
hab ich solch ein Array erstellt:


{36,36,'s'-87,'o'-87,'n'-87,'n'-87,'t'-87,'a'-87,'g'-87,36 },
{ 36,36,'m'-87,'o'-87,'n'-87,'t'-87,'a'-87,'g'-87,36,36 },
{ 36,'d'-87,'i'-87,'e'-87,'n'-87,'s'-87,'t'-87,'a'-87,'g'-87,36 },
{ 36,'m'-87,'i'-87,'t'-87,'t'-87,'w'-87,'o'-87,'c'-87,'h'-87,36 },
{ 'd'-87,'o'-87,'n'-87,'n'-87,'e'-87,'r'-87,'s'-87,'t'-87,'a'-87,'g'-87 },
{ 36,36,'f'-87,'r'-87,'e'-87,'i'-87,'t'-87,'a'-87,'g'-87,36 },
{ 36,36,'s'-87,'a'-87,'m'-87,'s'-87,'t'-87,'a'-87,'g'-87,36 }

};

Die RTC liefert eine 0 für Sonntag 1 für Montag usw.

Um einen einfachen Zugriff auf meine ASCII Tabelle zu bekommen, habe ich zwar die Buchstaben als ASCII Zeichen eingefügt gleichzeitig aber 87 davon abgezogen womit ich auch direkte Adressierung im Array bekomme (Zur Info es wird zu Kompilierzeit subtrahiert es verbraucht also keine Resourcen zu Laufzeit)
naja 36 ist dann direkt die Leerzeile.

der Rest ist denkbar einfach, ein Externer Interrupt startet einen Timer, in dem die Werte aus dem Flash ausgelesen werden, jedes Zeichen kriegt ein Zeitfenster, eine Variable wird inkrementiert um in den vertikalen Strichen weiterzuwandern, fertig es sieht etwa so aus:


if (flags.dat_tim == 0){
tmp = pgm_read_byte(&zeichen_k[time[zahl]][val]);
PORTD = tmp & 0xC0;
PORTB = tmp & 0x3F;
} else {
tmp = pgm_read_byte(&zeichen_k[date[zahl]][val+tmp2]);
asm volatile (

"ldi %2,8" "\n\t"
"0:" "\n\t"
"lsr %0" "\n\t"
"rol __tmp_reg__" "\n\t"
"dec %2" "\n\t"
"brne 0b" "\n\t"
"mov %0,__tmp_reg__" "\n\t"
: "=a" (tmp)
: "0" (tmp), "a" (count)
);
PORTD = tmp & 0xC0;
PORTB = tmp & 0x3F;
tmp2 += 2;
}
Ich will das ganze jetzt nicht weiter komentieren,
zahl ist wohl das Zeichen, das dargestellt werden soll, wohl global definiert und in der Hauptschleife gefüllt
val ist eine statische Variable die in jedem interrupt inkrementiert wird um das ASCII Array durchzuwandern
Der Inlineassembler dreht mir jetzt die Bits um, es wrd ja was oben und was unten gezeigt, unten müssen die Zeichen "auf dem Kopf" dargestellt werden ( aus z.B 11000000 muß dann 0000011 werden)
Da ich keine C idee hatte wurde halt zum Assembler gegriffen ;-)

Puh, wenn Du jetzt was mit anfangen kannst...

Gruß Sebastian

[Sternthaler]

Hallo


Es kann sein, daß CodeVision es anders macht, vielleicht braucht man hier kein PROGMEM und pgm_read*
Ich kenn mich mit CodeVision zwar nicht besonders aus, aber eigendlich kann es auch dort keinen 'Wahrsager' geben, der vorraussieht wohin ich meine Byte's schreiben möchte.
Von daher bleibt wirklich nur:

Da musst Du schon selber in der Doku zu Deinem Kompiler nachschlagen ;-)

[Roberto]

Hallo Sebastian

Puh, wenn Du jetzt was mit anfangen kannst...
Ganz zwar nicht, aber danke für die Mühe!!
Ich dachte Du hast da vielleicht eine String zerlegung drinnen, aber Du verwendest da nur Zahlen.

Muss mich jetzt mal umschauen um so eine Zerlegung :-k
(möchte das heute vielleicht noch zum laufen bekommen)

l.G. Roberto

[izaseba]

aber eigendlich kann es auch dort keinen 'Wahrsager' geben, der vorraussieht wohin ich meine Byte's schreiben möchte.

Ja das stimmt, vielleicht wird das alleine über const geregelt, das muß ja schon so sein, wenn das Programm bei Roberto funktioniert.

Gruß Sebastian

[izaseba]

aber Du verwendest da nur Zahlen.

Nein, ich hab da auch noch ein paar Strings drin :-)
Wie willst Du einen String denn zerlegen ?
über UART kommend oder wie ?
Ist ja kein Akt:
einen Puffer einrichten wo Zeichen gesamelt werden, (Sameln an besten in RX ISR) bis '\n' Empfangen wurde.
Wurde '\n' Empfangen setzt Du im Interrupt einen Flag, das der String komplett angekommen ist und am besten am Ende vom String ein '\0' anhängen.
Jetzt kann es in der Mainroutine zur Sache gehen, den Puffer solange durchlaufen, bis '\0' gefunden wird fertig.

also etwa so



char puffer[10];
char *zeiger_auf_puffer = puffer;

...
...
int main (void) {
char einzeichen;
for (;;) {
while(!flagvonderISR) ;
while (*zeiger_auf_puffer) {
einzeichen = *zeiger_auf_puffer++;
/*Hier kannst Du mit einzeichen machen was Du willst */
}
zeiger_auf_puffer = puffer;
flagvonderISR = 0;
}
Ich bitte um Verständnis für denk/Tippfehler , ich habe es eben aus dem Ärmel geschüttet ;-)

Gruß Sebastian

[Sternthaler]

Hallo
es sollte auch folgendes funktionieren bei der Stringverarbeitung:


char puffer[10];
char *zeiger_auf_puffer = puffer;

int main (void)
{
#define LEN_STR_1 3
char teil_str_1 [LEN_STR_1 + 1]; // 3 Byte langer String + \0

#define LEN_STR_2 7
char teil_str_1 [LEN_STR_2 + 1]; // 7 Byte langer String + \0

for (;;)
{
while (!flagvonderISR)
;

zeiger_auf_puffer = puffer;
teil_str_1 = strncpy (zeiger_auf_puffer, LEN_STR_1);
teil_str_1 [LEN_STR_1] = '\0'; // String in C abschliessen

zeiger_auf_puffer += LEN_STR_1; /* JA, die Vorgaengerlaenge */
teil_str_2 = strncpy (zeiger_auf_puffer, LEN_STR_2);
teil_str_2 [LEN_STR_2] = '\0'; // String in C abschliessen

/* Und ab hier kann mit den beiden Teil-Strings gearbeitet werden */

flagvonderISR = 0;
}

Aber Vorsicht mit den str...-Befehlen. Die fressen enorm viel Speicherplatz.

[izaseba]

Ja genau die string,h ist da auch eine gute Anlaufstelle, kommt immer drauf an, was man will, einzelne Zeichen kriegen, oder Teilstrings man kann eine Zeichenkette nach Leerzeichen/sonderzeichen zerschlagen, viele Wege führen nach Rom ;-)

Ich mein die string.h ist nicht sooo Speicherintensiv, da ist die stdio.h schon schlimmer, kommt auch auf den Kontroller an, auf dem Tiny 13 ist es vielleicht übertrieben die Bibliotheken einzubinden, ein M32 lacht drüber.
Wie dem auch sei, der Roberto kriegt es schon hin, neue Sprache zu erlernen ist immer mit Schmerz verbunden ;-)
Ich bin zur Zeit mit Perl dran, zwar nicht µC bezogen, aber hab da ähnliche Schwierigkeiten...

Gruß Sebastian

[Roberto]

Hallo

Soll ich dazu einen neuen Thread aufmachen?
Mache mal hier weiter:
https://www.roboternetz.de/phpBB2/viewtopic.php?p=303385#303385