ATNEL tech-forum 2016-10-25T06:02:00+01:00 https://forum.atnel.pl/feed.php?f=4&t=16460&mode 2016-10-25T06:02:00+01:00 2016-10-25T06:02:00+01:00 https://forum.atnel.pl/viewtopic.php?t=16460&p=172719#p172719 <![CDATA[Re: problem z bilblioteką OLED I2C]]>
[syntax=c]void SSD1306_drawBitmap_P(int x,int y , const uint8_t *bitmap , uint8_t w, uint8_t h,uint8_t color ){
int i,j,byteWidth = (w + 7) / 8;

for(j=0;j<h;j++){
for (i=0;i<w;i++){
if (pgm_read_byte(bitmap + j * byteWidth + i / 8 ) & ( 128 >> ( i & 7 )) ){
SSD1306_setPixel(x+i, y+j, color);
}
}
}
}[/syntax]

------------------------ [ Dodano po: 9 minutach ]

oraz funkcja rysowania znaku
[syntax=c]void SSD1306_drawChar(int x, int y, char c , uint8_t color, uint8_t bg, uint8_t size){

if ((x >= SSD1306_WIDTH)|| (y >= SSD1306_HEIGHT) || ((x + 6 * size-1 ) < 0) || ((y + 8 * size - 1)<0))return;


for (int8_t i = 0; i<6 ;i++){
uint8_t line;

if (i == 5)
line = 0x0;
else
line = pgm_read_byte(font + ( c * 5) +i);

for(int8_t j = 0 ;j<8; j++){
if(line & 0x1){
if(size==1)
SSD1306_setPixel(x+i, y+j, color);
else {
SSD1306_fillRect(x+(i*size), y+(j*size), size, size, color);
}

}else if (bg != color){
if (size == 1)
SSD1306_setPixel(x+i, y+j ,bg);
else {
SSD1306_fillRect(x + i * size, y+j*size, size, size, bg);
}

}
line >>= 1;
}
}

}[/syntax]

Statystyki: Napisane przez paul_K — 25 paź 2016, o 06:02

]]> 2016-10-12T10:12:16+01:00 2016-10-12T10:12:16+01:00 https://forum.atnel.pl/viewtopic.php?t=16460&p=171294#p171294 <![CDATA[Re: problem z bilblioteką OLED I2C]]> A kolega to przypadkiem tego: topic7402.html

nie widział ? .... proszę poprawić - jeśli wątek ma pozostać nie usunięty.

Statystyki: Napisane przez mirekk36 — 12 paź 2016, o 10:12

]]> 2016-10-12T11:12:46+01:00 2016-10-12T10:10:23+01:00 https://forum.atnel.pl/viewtopic.php?t=16460&p=171293#p171293 <![CDATA[problem z bilblioteką OLED I2C]]> zaczynam zabawę z oprogramowaniem wyświetlacza Oled



sprzęt:
atb1.05 + oled na i2c 128x64

co działa :
rysowanie pixela
rysowanie linii
rysowanie prostokąta
kasowanie oled


nie działa :
rysowanie bitmapy
rysowanie fontu


Proszę o sprawdzenie kodu i sugestie co może być źle
z góry dziękuje

dorzucam pliki biblioteki:


plik main.c

[syntax=c]#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>

#include "ssd1306/ssd1306.h"


const uint8_t bitmap1[] PROGMEM = {
// obrazek
};

int main( void )
{
DDRB |= (1<<PB0);

SSD1306_init( SSD1306_SWITCHCAPVCC, REFRESH_MID );

SSD1306_cls(); // czyszczenie zawertosci bufora

// SSD1306_drawLine(0,64,128,0,1);//rysuj linie
//SSD1306_fillRect(10,1,20,20,1);// rysuj prostokąt

SSD1306_drawBitmap_P(0,0,bitmap1,128,64,1); // rysuj bitmape
//SSD1306_drawChar(29,0,'A',1,0,1);// rysuj litere
SSD1306_display();//wyswietl

while(1)
{
}
}[/syntax]

plik ssd1306.c


[syntax=c]#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>
#include "ssd1306.h"


uint8_t ssd1306_buf[1024]={// bufor


};

void i2cSetBitrate(uint16_t bitrateKHz) {
uint8_t bitrate_div;

bitrate_div = ((F_CPU/1000UL)/bitrateKHz);
if(bitrate_div >= 16)
bitrate_div = (bitrate_div-16)/2;

TWBR = bitrate_div;
}

void TWI_start(void) {
TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWSTA);
while (!(TWCR&(1<<TWINT)));
}

void TWI_stop(void) {
TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
while ( !(TWCR&(1<<TWSTO)) );
}

void TWI_write(uint8_t bajt) {
TWDR = bajt;
TWCR = (1<<TWINT)|(1<<TWEN);
while ( !(TWCR&(1<<TWINT)));
}

uint8_t TWI_read(uint8_t ack) {
TWCR = (1<<TWINT)|(ack<<TWEA)|(1<<TWEN);

while ( !(TWCR & (1<<TWINT)) );

return TWDR;
}


void TWI_write_buf( uint8_t SLA, uint8_t adr, uint16_t len, uint8_t *buf) {

TWI_start();
TWI_write(SLA);
TWI_write(adr);
while (len--) TWI_write(*buf++);
TWI_stop();
}


//***************************** wysyłanie komend na i2C

void SSD1306_cmd(uint8_t cmd){


// funkcja wysyłania rozkazu po i2c
uint8_t control = 0x00;
TWI_start();
TWI_write( SSD1306_I2C_ADDRESS );
TWI_write( control );
TWI_write( cmd );
TWI_stop();

}
//*******************************************************************

//**********************************wysyłanie danych
void SSD1306_data(uint8_t dat){ // procedura tysłania danych na spi


// funkja wysyłania danych na spi
uint8_t control = 0x40;
TWI_start();
TWI_write( SSD1306_I2C_ADDRESS );
TWI_write( control );
TWI_write( dat );
TWI_stop();

}

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

void SSD1306_cls(void){
memset(ssd1306_buf,0x00,(1024));
}

// *****************************przeniesienie bufora na lcd
void SSD1306_display( void )
{
SSD1306_cmd( SSD1306_SETLOWCOLUMN | 0x0 );
SSD1306_cmd( SSD1306_SETHIGHCOLUMN | 0x0 );
SSD1306_cmd( SSD1306_SETSTARTLINE | 0x0 );


//Funkcje od TWI są takie same jak w BB. Jedyna modyfikacja:
// void TWI_write_buf( uint8_t SLA, uint8_t adr, [b]uint8_t[/b] len, uint8_t *buf )
// na
// void TWI_write_buf( uint8_t SLA, uint8_t adr, [b]uint16_t[/b] len, uint8_t *buf )

TWI_write_buf( SSD1306_I2C_ADDRESS, 0x40, 1024, ssd1306_buf );

}
//***********************************************************************************

/**
* FUNKCJA ZAPISUJĄCA STAN PIXALA W BUFORZE
*/
//*************************************************************
void SSD1306_setPixel(int x, int y, uint8_t bw )
{
if( (x < 0) || (x >= SSD1306_WIDTH) || (y < 0) || (y >= SSD1306_HEIGHT) )
return;

if(bw ) ssd1306_buf[x + (y/8) * SSD1306_WIDTH] |= (1<<(y%8));
else ssd1306_buf[x + (y/8) * SSD1306_WIDTH] &= ~(1<<(y%8));

}
//*****************************************************************

// inicjacja wyswietlacza
void SSD1306_init(uint8_t vcc, uint8_t refresh){

i2cSetBitrate(400);
I2C_DIR |= (1<<SCL)|(1<<SDA);
_delay_ms(50);


SSD1306_cmd(SSD1306_DISPLAYOFF);
SSD1306_cmd(SSD1306_SETDISPLAYCLOCKDIV);
SSD1306_cmd(refresh);

SSD1306_cmd(SSD1306_SETDISPLAYOFFSET);
SSD1306_cmd(0x00);

SSD1306_cmd(SSD1306_SETSTARTLINE|0x0);
SSD1306_cmd(SSD1306_CHARGEPUMP);

if (vcc == SSD1306_EXTERNALVCC) SSD1306_cmd(0x10);
else SSD1306_cmd(0x14);


SSD1306_cmd(SSD1306_MEMORYMODE);
SSD1306_cmd(0x00);
SSD1306_cmd(SSD1306_SEGREMAP|0x1);
SSD1306_cmd(SSD1306_COMSCANDEC);

SSD1306_cmd(SSD1306_SETCONTRAST);

if (vcc== SSD1306_EXTERNALVCC)SSD1306_cmd(0x9F);
else SSD1306_cmd(0xCF);

SSD1306_cmd(SSD1306_SETPRECHARGE);


#if defined SSD1306_128_32

SSD1306_cmd(SSD1306_SETMULTIPLEX);
SSD1306_cmd(0x1F);
SSD1306_cmd(SSD1306_SETCOMPINS);
SSD1306_cmd(0x02);

#endif

#if defined SSD1306_128_64

SSD1306_cmd(SSD1306_SETMULTIPLEX);
SSD1306_cmd(0x3F);
SSD1306_cmd(SSD1306_SETCOMPINS);
SSD1306_cmd(0x12);

#endif

SSD1306_cmd(SSD1306_DISPLAYALLON_RESUME);
SSD1306_cmd(SSD1306_NORMALDISPLAY);
SSD1306_cmd(SSD1306_DISPLAYON);

}

//**********************************************************************************************[/syntax]

plik ssd1306.h

[syntax=c]#ifndef SSD1306_H_
#define SSD1306_H_


#define SSD1306_128_64//definicja wielkosci wyswietlacza gdy nie uzywany to w komentarz
//#define SSD1306_128_32//definicja wielkosci wyswietlacza

#define USE_CS 0// jak używam to 1
#define USE_RST1

//#define USE_SPI_OR_I2C0// 1-SPI ,0-I2C

/**
* KONFIGURACJA SPRZĘTOWEGO I2C

*/
//#if USE_SPI_OR_I2C==0
// NA ARDUINO WYŚWIETLACZ PRACUJE POD ADRESEM 0x3C mimo iż na obudowie jest napisane 0x78
#define SSD1306_I2C_ADDRESS 0x78
//#define SSD1306_I2C_ADDRESS 0x3D
//#define SSD1306_I2C_ADDRESS 0x7A
//#define SSD1306_I2C_ADDRESS 0x78

#define I2C_DIR DDRC
#define SCL PC0
#define SDA PC1
//#endif


#define SSD1306_WIDTH 128// szerokosc wyswietlacza


#if defined SSD1306_128_64// wysokosc jeśli wybieramy
#define SSD1306_HEIGHT 64
#endif


#if defined SSD1306_128_32
#define SSD1306_HEIGHT 32
#endif

/**
* DEFINICJE SZYBKOŚCI ODŚWIEŻANIA
*/
#define REFRESH_MIN 0x80
#define REFRESH_MID 0xB0
#define REFRESH_MAX 0xF0


/**
* DEFINICJE KOMENDY STEROWNIKA
*/
#define SSD1306_SETCONTRAST 0x81
#define SSD1306_DISPLAYALLON_RESUME 0xA4
#define SSD1306_DISPLAYALLON 0xA5
#define SSD1306_NORMALDISPLAY 0xA6
#define SSD1306_INVERTDISPLAY 0xA7
#define SSD1306_DISPLAYOFF 0xAE
#define SSD1306_DISPLAYON 0xAF
#define SSD1306_SETDISPLAYOFFSET 0xD3
#define SSD1306_SETCOMPINS 0xDA
#define SSD1306_SETVCOMDETECT 0xDB
#define SSD1306_SETDISPLAYCLOCKDIV 0xD5
#define SSD1306_SETPRECHARGE 0xD9
#define SSD1306_SETMULTIPLEX 0xA8
#define SSD1306_SETLOWCOLUMN 0x00
#define SSD1306_SETHIGHCOLUMN 0x10
#define SSD1306_SETSTARTLINE 0x40
#define SSD1306_MEMORYMODE 0x20
#define SSD1306_COLUMNADDR 0x21
#define SSD1306_PAGEADDR 0x22
#define SSD1306_COMSCANINC 0xC0
#define SSD1306_COMSCANDEC 0xC8
#define SSD1306_SEGREMAP 0xA0
#define SSD1306_CHARGEPUMP 0x8D
#define SSD1306_EXTERNALVCC 0x1
#define SSD1306_SWITCHCAPVCC 0x2
#define SSD1306_ACTIVATE_SCROLL 0x2F
#define SSD1306_DEACTIVATE_SCROLL 0x2E
#define SSD1306_SET_VERTICAL_SCROLL_AREA 0xA3
#define SSD1306_RIGHT_HORIZONTAL_SCROLL 0x26
#define SSD1306_LEFT_HORIZONTAL_SCROLL 0x27
#define SSD1306_VERTICAL_AND_RIGHT_HORIZONTAL_SCROLL 0x29
#define SSD1306_VERTICAL_AND_LEFT_HORIZONTAL_SCROLL 0x2A


#define swap(a,b) {int16_t t = a ; a = b ; b = t; }


/*********************deklaracja zmiennych
*/
extern const uint8_t font[];
extern int cursor_x,cursor_y;
/**
* DEKLARACJE FUNKCJI
*/


void SSd1306_init( uint8_t vcc, uint8_t refresh );
void SS1306_cmd(uint8_t cmd );
void SSD1306_data( uint8_t data );

void SSD1306_display( void );// wyslij na ekran z bufor
void SSD1306_setPixel(int x, int y, uint8_t color );// zapal pizel w buforze
void SSD1306_cls(void);// czyszczenie zawartosci bufora

//funkcje graficzne
void SSD1306_drawBitmap_P(int x,int y , const uint8_t *bitmap, uint8_t w, uint8_t h,uint8_t color ); // rysowanie bitmapy
void SSD1306_drawChar(int x, int y, char c , uint8_t color, uint8_t bg, uint8_t size); // wysowanie litery y lewy gorny róg litery kod asci litery 'A', kolor =1 , tło= 0 , rozmiar standard 1
void SSD1306_fillRect(int x , int y , int w , int h , uint8_t color); // rysowanie prostokata x,y górny lewy róg prostokata, w szerokosc , h wysokosc
void SSD1306_drawFastVLine(int x, int y,int h,uint8_t color);
void SSD1306_drawLine(int x0 , int y0 ,int x1, int y1, uint8_t color );// rysowanie linii



#endif /* SSD1306_H_ */[/syntax]

plik ssd_graphic.c

[syntax=c]#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>

#include "ssd1306.h"

int cursor_x,cursor_y;

void SSD1306_drawLine(int x0 , int y0 ,int x1, int y1, uint8_t color );
void SSD1306_drawFastVLine(int x, int y,int h,uint8_t color);
void SSD1306_fillRect(int x, int y, int w,int h, uint8_t color);


void SSD1306_drawBitmap_P(int x,int y , const uint8_t *bitmap , uint8_t w, uint8_t h,uint8_t color ){
int i,j,byteWidth = (w + 7) / 8;

for(j=0;j<h;j++){
for (i=0;j<w;i++){
if (pgm_read_byte(bitmap + j * byteWidth + 1 / 8 ) & ( 128 >> ( i & 7 )) ){
SSD1306_setPixel(x+i, y+j, color);
}
}

}
}

void SSD1306_drawChar(int x, int y, char c , uint8_t color, uint8_t bg, uint8_t size){

if ((x>=SSD1306_WIDTH)|| (y>=SSD1306_HEIGHT)||((x + 6 * size-1)<0)||((y+8*size-1)<0))return;
uint8_t line;

for (int8_t i=0;i<6;i++){


if (i==5)
line=0x0;
else

line = pgm_read_byte(font+(c*5)+i);

for(int8_t j=0 ;j<0;j++){
if(size & 0x1){
if(size==1)
SSD1306_setPixel(x+i,y+j,color);
else {SSD1306_fillRect(x+(i*size),y+(j*size),size,size,color);
}

}else if (bg != color){
if (size==1)
SSD1306_setPixel(x=i,y+j,bg);
else {
SSD1306_fillRect(x+i * size, y+j* size,size,size, bg);
}

}
line>>=1;
}
}
}

void SSD1306_fillRect(int x, int y, int w,int h, uint8_t color){
for (int16_t i=x;i<x+w;i++){
SSD1306_drawFastVLine(i,y,h,color);
}
}
void SSD1306_drawFastVLine(int x, int y,int h,uint8_t color){

SSD1306_drawLine(x,y,x,y+h-1,color);
}

void SSD1306_drawLine(int x0 , int y0 ,int x1, int y1, uint8_t color ){
int steep =abs(y1-y0)>abs(x1-x0);

if (steep) {
swap(x0,y0);
swap(x1,y1);
}

if(x0>x1) {
swap(x0,x1);
swap(y0,y1);
};

int dx,dy;
dx=x1-x0;
dy=abs(y1-y0);

int err = dx/2;
int ystep;

if(y0<y1){
ystep=1;
}else{ystep=-1;}

for(;x0<=x1;x0++){
if(steep){
SSD1306_setPixel(y0,x0,color);
}else{
SSD1306_setPixel(x0,y0,color);
}
err -=dy;
if (err<0){
y0+=ystep;
err+=dx;
}
}

}[/syntax]

oraz plik oled_font1.c

[syntax=c]// This is the 'classic' fixed-space bitmap font for Adafruit_GFX since 1.0.
// See gfxfont.h for newer custom bitmap font info.

#ifndef FONT5X7_H
#define FONT5X7_H

//#ifdef __AVR__
#include <avr/io.h>
#include <avr/pgmspace.h>

// Standard ASCII 5x7 font

const uint8_t font[] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00,
0x3E, 0x5B, 0x4F, 0x5B, 0x3E,
0x3E, 0x6B, 0x4F, 0x6B, 0x3E,
0x1C, 0x3E, 0x7C, 0x3E, 0x1C,
0x18, 0x3C, 0x7E, 0x3C, 0x18,
0x1C, 0x57, 0x7D, 0x57, 0x1C,
0x1C, 0x5E, 0x7F, 0x5E, 0x1C,
0x00, 0x18, 0x3C, 0x18, 0x00,
0xFF, 0xE7, 0xC3, 0xE7, 0xFF,
0x00, 0x18, 0x24, 0x18, 0x00,
0xFF, 0xE7, 0xDB, 0xE7, 0xFF,
0x30, 0x48, 0x3A, 0x06, 0x0E,
0x26, 0x29, 0x79, 0x29, 0x26,
0x40, 0x7F, 0x05, 0x05, 0x07,
0x40, 0x7F, 0x05, 0x25, 0x3F,
0x5A, 0x3C, 0xE7, 0x3C, 0x5A,
0x7F, 0x3E, 0x1C, 0x1C, 0x08,
0x08, 0x1C, 0x1C, 0x3E, 0x7F,
0x14, 0x22, 0x7F, 0x22, 0x14,
0x5F, 0x5F, 0x00, 0x5F, 0x5F,
0x06, 0x09, 0x7F, 0x01, 0x7F,
0x00, 0x66, 0x89, 0x95, 0x6A,
0x60, 0x60, 0x60, 0x60, 0x60,
0x94, 0xA2, 0xFF, 0xA2, 0x94,
0x08, 0x04, 0x7E, 0x04, 0x08,
0x10, 0x20, 0x7E, 0x20, 0x10,
0x08, 0x08, 0x2A, 0x1C, 0x08,
0x08, 0x1C, 0x2A, 0x08, 0x08,
0x1E, 0x10, 0x10, 0x10, 0x10,
0x0C, 0x1E, 0x0C, 0x1E, 0x0C,
0x30, 0x38, 0x3E, 0x38, 0x30,
0x06, 0x0E, 0x3E, 0x0E, 0x06,
0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x5F, 0x00, 0x00,
0x00, 0x07, 0x00, 0x07, 0x00,
0x14, 0x7F, 0x14, 0x7F, 0x14,
0x24, 0x2A, 0x7F, 0x2A, 0x12,
0x23, 0x13, 0x08, 0x64, 0x62,
0x36, 0x49, 0x56, 0x20, 0x50,
0x00, 0x08, 0x07, 0x03, 0x00,
0x00, 0x1C, 0x22, 0x41, 0x00,
0x00, 0x41, 0x22, 0x1C, 0x00,
0x2A, 0x1C, 0x7F, 0x1C, 0x2A,
0x08, 0x08, 0x3E, 0x08, 0x08,
0x00, 0x80, 0x70, 0x30, 0x00,
0x08, 0x08, 0x08, 0x08, 0x08,
0x00, 0x00, 0x60, 0x60, 0x00,
0x20, 0x10, 0x08, 0x04, 0x02,
0x3E, 0x51, 0x49, 0x45, 0x3E,
0x00, 0x42, 0x7F, 0x40, 0x00,
0x72, 0x49, 0x49, 0x49, 0x46,
0x21, 0x41, 0x49, 0x4D, 0x33,
0x18, 0x14, 0x12, 0x7F, 0x10,
0x27, 0x45, 0x45, 0x45, 0x39,
0x3C, 0x4A, 0x49, 0x49, 0x31,
0x41, 0x21, 0x11, 0x09, 0x07,
0x36, 0x49, 0x49, 0x49, 0x36,
0x46, 0x49, 0x49, 0x29, 0x1E,
0x00, 0x00, 0x14, 0x00, 0x00,
0x00, 0x40, 0x34, 0x00, 0x00,
0x00, 0x08, 0x14, 0x22, 0x41,
0x14, 0x14, 0x14, 0x14, 0x14,
0x00, 0x41, 0x22, 0x14, 0x08,
0x02, 0x01, 0x59, 0x09, 0x06,
0x3E, 0x41, 0x5D, 0x59, 0x4E,
0x7C, 0x12, 0x11, 0x12, 0x7C,
0x7F, 0x49, 0x49, 0x49, 0x36,
0x3E, 0x41, 0x41, 0x41, 0x22,
0x7F, 0x41, 0x41, 0x41, 0x3E,
0x7F, 0x49, 0x49, 0x49, 0x41,
0x7F, 0x09, 0x09, 0x09, 0x01,
0x3E, 0x41, 0x41, 0x51, 0x73,
0x7F, 0x08, 0x08, 0x08, 0x7F,
0x00, 0x41, 0x7F, 0x41, 0x00,
0x20, 0x40, 0x41, 0x3F, 0x01,
0x7F, 0x08, 0x14, 0x22, 0x41,
0x7F, 0x40, 0x40, 0x40, 0x40,
0x7F, 0x02, 0x1C, 0x02, 0x7F,
0x7F, 0x04, 0x08, 0x10, 0x7F,
0x3E, 0x41, 0x41, 0x41, 0x3E,
0x7F, 0x09, 0x09, 0x09, 0x06,
0x3E, 0x41, 0x51, 0x21, 0x5E,
0x7F, 0x09, 0x19, 0x29, 0x46,
0x26, 0x49, 0x49, 0x49, 0x32,
0x03, 0x01, 0x7F, 0x01, 0x03,
0x3F, 0x40, 0x40, 0x40, 0x3F,
0x1F, 0x20, 0x40, 0x20, 0x1F,
0x3F, 0x40, 0x38, 0x40, 0x3F,
0x63, 0x14, 0x08, 0x14, 0x63,
0x03, 0x04, 0x78, 0x04, 0x03,
0x61, 0x59, 0x49, 0x4D, 0x43,
0x00, 0x7F, 0x41, 0x41, 0x41,
0x02, 0x04, 0x08, 0x10, 0x20,
0x00, 0x41, 0x41, 0x41, 0x7F,
0x04, 0x02, 0x01, 0x02, 0x04,
0x40, 0x40, 0x40, 0x40, 0x40,
0x00, 0x03, 0x07, 0x08, 0x00,
0x20, 0x54, 0x54, 0x78, 0x40,
0x7F, 0x28, 0x44, 0x44, 0x38,
0x38, 0x44, 0x44, 0x44, 0x28,
0x38, 0x44, 0x44, 0x28, 0x7F,
0x38, 0x54, 0x54, 0x54, 0x18,
0x00, 0x08, 0x7E, 0x09, 0x02,
0x18, 0xA4, 0xA4, 0x9C, 0x78,
0x7F, 0x08, 0x04, 0x04, 0x78,
0x00, 0x44, 0x7D, 0x40, 0x00,
0x20, 0x40, 0x40, 0x3D, 0x00,
0x7F, 0x10, 0x28, 0x44, 0x00,
0x00, 0x41, 0x7F, 0x40, 0x00,
0x7C, 0x04, 0x78, 0x04, 0x78,
0x7C, 0x08, 0x04, 0x04, 0x78,
0x38, 0x44, 0x44, 0x44, 0x38,
0xFC, 0x18, 0x24, 0x24, 0x18,
0x18, 0x24, 0x24, 0x18, 0xFC,
0x7C, 0x08, 0x04, 0x04, 0x08,
0x48, 0x54, 0x54, 0x54, 0x24,
0x04, 0x04, 0x3F, 0x44, 0x24,
0x3C, 0x40, 0x40, 0x20, 0x7C,
0x1C, 0x20, 0x40, 0x20, 0x1C,
0x3C, 0x40, 0x30, 0x40, 0x3C,
0x44, 0x28, 0x10, 0x28, 0x44,
0x4C, 0x90, 0x90, 0x90, 0x7C,
0x44, 0x64, 0x54, 0x4C, 0x44,
0x00, 0x08, 0x36, 0x41, 0x00,
0x00, 0x00, 0x77, 0x00, 0x00,
0x00, 0x41, 0x36, 0x08, 0x00,
0x02, 0x01, 0x02, 0x04, 0x02,
0x3C, 0x26, 0x23, 0x26, 0x3C,
0x1E, 0xA1, 0xA1, 0x61, 0x12,
0x3A, 0x40, 0x40, 0x20, 0x7A,
0x38, 0x54, 0x54, 0x55, 0x59,
0x21, 0x55, 0x55, 0x79, 0x41,
0x22, 0x54, 0x54, 0x78, 0x42, // a-umlaut
0x21, 0x55, 0x54, 0x78, 0x40,
0x20, 0x54, 0x55, 0x79, 0x40,
0x0C, 0x1E, 0x52, 0x72, 0x12,
0x39, 0x55, 0x55, 0x55, 0x59,
0x39, 0x54, 0x54, 0x54, 0x59,
0x39, 0x55, 0x54, 0x54, 0x58,
0x00, 0x00, 0x45, 0x7C, 0x41,
0x00, 0x02, 0x45, 0x7D, 0x42,
0x00, 0x01, 0x45, 0x7C, 0x40,
0x7D, 0x12, 0x11, 0x12, 0x7D, // A-umlaut
0xF0, 0x28, 0x25, 0x28, 0xF0,
0x7C, 0x54, 0x55, 0x45, 0x00,
0x20, 0x54, 0x54, 0x7C, 0x54,
0x7C, 0x0A, 0x09, 0x7F, 0x49,
0x32, 0x49, 0x49, 0x49, 0x32,
0x3A, 0x44, 0x44, 0x44, 0x3A, // o-umlaut
0x32, 0x4A, 0x48, 0x48, 0x30,
0x3A, 0x41, 0x41, 0x21, 0x7A,
0x3A, 0x42, 0x40, 0x20, 0x78,
0x00, 0x9D, 0xA0, 0xA0, 0x7D,
0x3D, 0x42, 0x42, 0x42, 0x3D, // O-umlaut
0x3D, 0x40, 0x40, 0x40, 0x3D,
0x3C, 0x24, 0xFF, 0x24, 0x24,
0x48, 0x7E, 0x49, 0x43, 0x66,
0x2B, 0x2F, 0xFC, 0x2F, 0x2B,
0xFF, 0x09, 0x29, 0xF6, 0x20,
0xC0, 0x88, 0x7E, 0x09, 0x03,
0x20, 0x54, 0x54, 0x79, 0x41,
0x00, 0x00, 0x44, 0x7D, 0x41,
0x30, 0x48, 0x48, 0x4A, 0x32,
0x38, 0x40, 0x40, 0x22, 0x7A,
0x00, 0x7A, 0x0A, 0x0A, 0x72,
0x7D, 0x0D, 0x19, 0x31, 0x7D,
0x26, 0x29, 0x29, 0x2F, 0x28,
0x26, 0x29, 0x29, 0x29, 0x26,
0x30, 0x48, 0x4D, 0x40, 0x20,
0x38, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08, 0x38,
0x2F, 0x10, 0xC8, 0xAC, 0xBA,
0x2F, 0x10, 0x28, 0x34, 0xFA,
0x00, 0x00, 0x7B, 0x00, 0x00,
0x08, 0x14, 0x2A, 0x14, 0x22,
0x22, 0x14, 0x2A, 0x14, 0x08,
0x55, 0x00, 0x55, 0x00, 0x55, // #176 (25% block) missing in old code
0xAA, 0x55, 0xAA, 0x55, 0xAA, // 50% block
0xFF, 0x55, 0xFF, 0x55, 0xFF, // 75% block
0x00, 0x00, 0x00, 0xFF, 0x00,
0x10, 0x10, 0x10, 0xFF, 0x00,
0x14, 0x14, 0x14, 0xFF, 0x00,
0x10, 0x10, 0xFF, 0x00, 0xFF,
0x10, 0x10, 0xF0, 0x10, 0xF0,
0x14, 0x14, 0x14, 0xFC, 0x00,
0x14, 0x14, 0xF7, 0x00, 0xFF,
0x00, 0x00, 0xFF, 0x00, 0xFF,
0x14, 0x14, 0xF4, 0x04, 0xFC,
0x14, 0x14, 0x17, 0x10, 0x1F,
0x10, 0x10, 0x1F, 0x10, 0x1F,
0x14, 0x14, 0x14, 0x1F, 0x00,
0x10, 0x10, 0x10, 0xF0, 0x00,
0x00, 0x00, 0x00, 0x1F, 0x10,
0x10, 0x10, 0x10, 0x1F, 0x10,
0x10, 0x10, 0x10, 0xF0, 0x10,
0x00, 0x00, 0x00, 0xFF, 0x10,
0x10, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0x10, 0xFF, 0x10,
0x00, 0x00, 0x00, 0xFF, 0x14,
0x00, 0x00, 0xFF, 0x00, 0xFF,
0x00, 0x00, 0x1F, 0x10, 0x17,
0x00, 0x00, 0xFC, 0x04, 0xF4,
0x14, 0x14, 0x17, 0x10, 0x17,
0x14, 0x14, 0xF4, 0x04, 0xF4,
0x00, 0x00, 0xFF, 0x00, 0xF7,
0x14, 0x14, 0x14, 0x14, 0x14,
0x14, 0x14, 0xF7, 0x00, 0xF7,
0x14, 0x14, 0x14, 0x17, 0x14,
0x10, 0x10, 0x1F, 0x10, 0x1F,
0x14, 0x14, 0x14, 0xF4, 0x14,
0x10, 0x10, 0xF0, 0x10, 0xF0,
0x00, 0x00, 0x1F, 0x10, 0x1F,
0x00, 0x00, 0x00, 0x1F, 0x14,
0x00, 0x00, 0x00, 0xFC, 0x14,
0x00, 0x00, 0xF0, 0x10, 0xF0,
0x10, 0x10, 0xFF, 0x10, 0xFF,
0x14, 0x14, 0x14, 0xFF, 0x14,
0x10, 0x10, 0x10, 0x1F, 0x00,
0x00, 0x00, 0x00, 0xF0, 0x10,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
0xFF, 0xFF, 0xFF, 0x00, 0x00,
0x00, 0x00, 0x00, 0xFF, 0xFF,
0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
0x38, 0x44, 0x44, 0x38, 0x44,
0xFC, 0x4A, 0x4A, 0x4A, 0x34, // sharp-s or beta
0x7E, 0x02, 0x02, 0x06, 0x06,
0x02, 0x7E, 0x02, 0x7E, 0x02,
0x63, 0x55, 0x49, 0x41, 0x63,
0x38, 0x44, 0x44, 0x3C, 0x04,
0x40, 0x7E, 0x20, 0x1E, 0x20,
0x06, 0x02, 0x7E, 0x02, 0x02,
0x99, 0xA5, 0xE7, 0xA5, 0x99,
0x1C, 0x2A, 0x49, 0x2A, 0x1C,
0x4C, 0x72, 0x01, 0x72, 0x4C,
0x30, 0x4A, 0x4D, 0x4D, 0x30,
0x30, 0x48, 0x78, 0x48, 0x30,
0xBC, 0x62, 0x5A, 0x46, 0x3D,
0x3E, 0x49, 0x49, 0x49, 0x00,
0x7E, 0x01, 0x01, 0x01, 0x7E,
0x2A, 0x2A, 0x2A, 0x2A, 0x2A,
0x44, 0x44, 0x5F, 0x44, 0x44,
0x40, 0x51, 0x4A, 0x44, 0x40,
0x40, 0x44, 0x4A, 0x51, 0x40,
0x00, 0x00, 0xFF, 0x01, 0x03,
0xE0, 0x80, 0xFF, 0x00, 0x00,
0x08, 0x08, 0x6B, 0x6B, 0x08,
0x36, 0x12, 0x36, 0x24, 0x36,
0x06, 0x0F, 0x09, 0x0F, 0x06,
0x00, 0x00, 0x18, 0x18, 0x00,
0x00, 0x00, 0x10, 0x10, 0x00,
0x30, 0x40, 0xFF, 0x01, 0x01,
0x00, 0x1F, 0x01, 0x01, 0x1E,
0x00, 0x19, 0x1D, 0x17, 0x12,
0x00, 0x3C, 0x3C, 0x3C, 0x3C,
0x00, 0x00, 0x00, 0x00, 0x00 // #255 NBSP
};
#endif // FONT5X7_H[/syntax]

Statystyki: Napisane przez paul_K — 12 paź 2016, o 10:10

]]>