początek, działa lcd i klawiatura

1wire.c

@@ -0,0 +1,135 @@
+#include "1wire.h"
+#include <util/delay.h>
+#include <avr/interrupt.h>
+#include <avr/wdt.h>
+
+#ifdef SEARCHROM
+#ifdef INITST
+unsigned char initst;
+#endif
+#endif
+
+unsigned char _1WireInit(void){
+	unsigned char out=0;
+	_1WPORT &= ~_1WL;
+	_1WLOW();
+	_delay_us(480);
+	cli();
+	_1WHIGH();
+	_delay_us(70);
+	if(!_1WISHIGH()) out++;
+	sei();
+	_delay_us(410);
+	if(!_1WISHIGH()) out++;
+	return out; // 0 - zwarcie, 1 - ok, 2 - rozwarcie
+}
+
+void _1WireWriteByte(unsigned char data){
+	register unsigned char i;
+	for(i=0;i<8;i++){
+		_1WireWriteSlot(data&1,0);
+		data >>= 1;
+	}
+}
+
+void _1WireWriteBytePR(unsigned char data){ //natychmiast po poleceniu włącz zasilanie
+	register unsigned char i;
+	for(i=0;i<7;i++){
+		_1WireWriteSlot(data&1,0);
+		data >>= 1;
+	}
+	_1WireWriteSlot(data,1);
+	_1WPORT |= _1WL;
+	_1WDDR |= _1WL;
+	sei();
+	if(!_1WISHIGH()) _1WirePoweroff();
+}
+
+
+void _1WireWriteSlot(unsigned char x, unsigned char pr){
+	cli();
+	_1WLOW();
+	if(x) _delay_us(6); else _delay_us(60);
+	_1WHIGH();
+	if(x) _delay_us(64); else _delay_us(10);
+	if(!pr) sei();
+	_delay_us(1);
+}
+
+unsigned char _1WireReadByte(void){
+	register unsigned char i=1;
+	unsigned char data=0;
+	while(i){
+		if(_1WireReadSlot()) data |= i;
+		i <<= 1;
+	}
+	return data;
+}
+
+unsigned char _1WireReadSlot(void){
+	unsigned char out=0;
+	cli();
+	_1WLOW();
+	_delay_us(6);
+	_1WHIGH();
+	_delay_us(9);
+	if(_1WISHIGH()) out=1;
+	sei();
+	_delay_us(55);
+	return out;
+}
+/*
+void _1WirePoweroff(void){ //wyłacz zasilanie
+	_1WDDR &= ~_1WL;
+	_1WPORT &= ~_1WL;
+}*/
+
+#ifdef SEARCHROM
+
+unsigned char _1WireSearch(unsigned char rv, unsigned char *buf){
+	unsigned char i,a,b,mask=1,lz=0;
+#ifdef INITST
+	if((initst = _1WireInit())!=1) return 0xff;
+#else
+	if(_1WireInit()!=1) return 0xff;
+#endif
+	_1WireWriteByte(0xf0);
+	for(i=1;i<65;i++){
+		a = _1WireReadSlot();
+		b = _1WireReadSlot();
+		if(a && b) return 0xff;
+		if(a==b) {
+			if(i>rv) a = 0;
+			else if(i==rv) a = 1;
+			else a = !!((*buf)&mask);
+			if(!a) lz=i;
+		}
+		_1WireWriteSlot(a,0);
+		if(a) (*buf)|=mask; else (*buf)&=~mask;
+		mask<<=1;
+		if(!mask){
+			mask = 1;
+			buf++;
+		}
+	}
+	rv=lz;
+	return rv;
+}
+
+void _1WireSendRom(unsigned char *rom){
+	register unsigned char i;
+	for(i=0;i<8;i++){
+		_1WireWriteByte(rom[i]);
+	}
+}
+#endif
+/*
+
+	unsigned char tablica_z_adresami[MAX_NUM][8];
+	unsigned char rom[8];
+	unsigned char i=0, rv=0;
+	do {
+		rv = _1WireSearch(rv, rom);
+		memcpy(tablica_z_adresami[i], rom, 8);
+		i++;
+	} while(!rv || i<MAX_NUM);*/

1wire.h

@@ -0,0 +1,34 @@
+#ifndef _1WIRE_H
+#define _1WIRE_H
+
+#define SEARCHROM
+#define INITST
+
+#ifdef INITST
+extern unsigned char initst;
+#endif
+
+#include <avr/io.h>
+
+#define _1WPORT PORTC
+#define _1WDDR DDRC
+#define _1WPIN PINC
+#define _1WL _BV(PC6)
+
+unsigned char _1WireInit(void);
+void _1WireWriteSlot(unsigned char bit, unsigned char pr);
+unsigned char _1WireReadSlot(void);
+void _1WireWriteByte(unsigned char dana);
+void _1WireWriteBytePR(unsigned char dana);
+unsigned char _1WireReadByte(void);
+void _1WirePoweroff(void);
+void _1WireSendRom(unsigned char *rom);
+unsigned char _1WireSearch(unsigned char rv, unsigned char *buf);
+
+#define _1WLOW() _1WDDR |= _1WL;
+#define _1WHIGH() _1WDDR &= ~_1WL;
+#define _1WISHIGH() (_1WPIN & _1WL)
+
+#define _1WirePoweroff() { _1WDDR &= ~_1WL; _1WPORT &= ~_1WL; }
+
+#endif

Makefile

@@ -0,0 +1,63 @@
+PRG            = SZM2
+OBJ            = main.o 1wire.o gtext.o sed1335.o ds18b20.o display.o
+MCU_TARGET     = atmega644p
+OPTIMIZE       = -Os
+# -mcall-prologues
+DEFS           = -DF_CPU=16000000
+LIBS           =
+ASMFLAGS       =
+AVRDUDE        = avrdude -c usbasp -p $(MCU_TARGET)
+# You should not have to change anything below here.
+CC             = avr-gcc
+# Override is only needed by avr-lib build system.
+override CFLAGS        = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) $(DEFS) -I/usr/avr/include -ffreestanding -fshort-enums -funsigned-bitfields
+#-save-temps
+override LDFLAGS       = -Wl,-Map,$(PRG).map
+OBJCOPY        = avr-objcopy
+OBJDUMP        = avr-objdump
+all: $(PRG).elf lst text #asm
+	avr-size $(PRG).elf
+	avr-size $(PRG).hex
+$(PRG).elf: $(OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS)
+#asm: usbdrvasm.S
+#	$(CC) $(INCLUDES) $(CFLAGS) $(DEFS) $(ASMFLAGS) -c $<
+clean:
+	rm -rf *.o $(PRG).elf *.eps *.png *.pdf *.bak
+	rm -rf *.lst *.map $(EXTRA_CLEAN_FILES)
+lst:  $(PRG).lst
+%.lst: %.elf
+	$(OBJDUMP) -d $< > $@
+# Rules for building the .text rom images
+text: hex
+#bin srec
+hex:  $(PRG).hex
+bin:  $(PRG).bin
+srec: $(PRG).srec
+%.hex: %.elf
+	$(OBJCOPY) -j .text -j .data -O ihex $< $@
+%.srec: %.elf
+	$(OBJCOPY) -j .text -j .data -O srec $< $@
+%.bin: %.elf
+	$(OBJCOPY) -j .text -j .data -O binary $< $@
+# Every thing below here is used by avr-libc's build system and can be ignored
+# by the casual user.
+FIG2DEV                 = fig2dev
+EXTRA_CLEAN_FILES       = *.hex *.bin *.srec *.s *.i *~
+dox: eps png pdf
+eps: $(PRG).eps
+png: $(PRG).png
+pdf: $(PRG).pdf
+%.eps: %.fig
+	$(FIG2DEV) -L eps $< $@
+%.pdf: %.fig
+	$(FIG2DEV) -L pdf $< $@
+%.png: %.fig
+	$(FIG2DEV) -L png $< $@
+program: install
+install: all
+	$(AVRDUDE) -U flash:w:$(PRG).hex
+reset:
+	$(AVRDUDE)
+fuses:
+	$(AVRDUDE) -U lfuse:w:0xff:m -U hfuse:w:0x11:m -U efuse:w:0xfd:m -B100

display.c

@@ -0,0 +1,58 @@
+#include "display.h"
+#include "gtext.h"
+
+void disp_num(signed int val){
+	unsigned char disp = 0, digit;
+	if(val < 0){
+		putchar('-');
+		val = -val;
+	} else {
+		putchar(' ');
+	}
+	digit = val/10000;
+	if(digit){
+		putchar(digit + '0');
+		disp = 1;
+	} else putchar(' ');
+	digit = (val/1000)%10;
+	if(digit || disp){
+		putchar(digit + '0');
+		disp = 1;
+	} else putchar(' ');
+	digit = (val/100)%10;
+	if(digit || disp){
+		putchar(digit + '0');
+		disp = 1;
+	} else putchar(' ');
+	digit = (val/10)%10;
+	if(digit || disp){
+		putchar(digit + '0');
+	} else putchar(' ');
+	digit = val%10;
+	putchar(digit + '0');
+}
+
+void disp_temp(signed int temp){
+	unsigned char pos = 0;
+	if(temp < 0){
+		putchar('-');
+		pos++;
+		temp = -temp;
+	}
+	if(temp >= 1000){
+		putchar(temp/1000 + '0');
+		pos++;
+	}
+	if(temp >= 100){
+		putchar((temp/100)%10 + '0');
+		pos++;
+	}
+	putchar((temp/10)%10 + '0');
+	putchar(',');
+	putchar(temp%10 + '0');
+	putchar(0x7b);
+	putchar('C');
+	pos+=5;
+	for(; pos<8; pos++) putchar(' ');
+}
+

display.h

@@ -0,0 +1,4 @@
+#pragma once
+
+void disp_num(signed int val);
+void disp_temp(signed int temp);

ds18b20.c

@@ -0,0 +1,97 @@
+#include <string.h>
+#include <util/crc16.h>
+#include <util/delay.h>
+#include "main.h"
+#include "ds18b20.h"
+#include "1wire.h"
+
+union {
+	signed int t;
+	unsigned char owbuffer[9];
+} t;
+
+#define MAX_ERRORS 5
+
+unsigned char rom_num;
+unsigned char rom_tab[MAX_SENSOR_NUM][8];
+unsigned char temp_ok;
+signed int temps[MAX_SENSOR_NUM];
+
+unsigned char find_1wire(void){
+	unsigned char rom[8];
+	unsigned char i=0, rv=0, j;
+	unsigned char crc = 0;
+	do {
+		rv = _1WireSearch(rv, rom);
+		memcpy(rom_tab[i], rom, 8);
+		for(j=0;j<8;j++){
+			crc = _crc_ibutton_update(crc, rom[j]);
+		}
+		if(crc) return 1;
+		i++;
+	} while(rv && i<MAX_SENSOR_NUM);
+	rom_num = i;
+	return 0;
+}
+
+void gettemp(void){
+	unsigned char i, j, crc=0, tmp;
+	static unsigned char error_cnt[MAX_SENSOR_NUM];
+	signed int temp;
+	unsigned char temp_ok_out = 0;
+
+	if(timers.owire) return;
+
+	_1WirePoweroff();
+	_delay_ms(1);
+
+	for(j=0; j<rom_num; j++){
+
+		if(_1WireInit() != 1){
+			rom_num = 0;
+			break;
+		}
+
+		_1WireWriteByte(0x55);
+		_1WireSendRom(rom_tab[j]);
+		_1WireWriteByte(0xbe);
+
+		for(i=0;i<9;i++){
+			tmp = _1WireReadByte();
+			t.owbuffer[i] = tmp;
+			crc = _crc_ibutton_update(crc, tmp);
+		}
+		if(!crc){
+			if(t.owbuffer[0] == 0x50 && t.owbuffer[1] == 0x05 && t.owbuffer[5] == 0xff && t.owbuffer[7] == 0x10) continue;
+
+			temp = t.t;
+			temp *= (int)(0.625*16);
+			temp >>= 4;
+			if(t.owbuffer[2] <= MAX_SENSOR_NUM){
+				temps[t.owbuffer[2]] = temp;
+				temp_ok_out |= 1<<t.owbuffer[2];
+			}
+		}
+	}
+
+	for(i=0; i<MAX_SENSOR_NUM; i++){
+		if(!(temp_ok_out & (1<<i))){
+			if(error_cnt[i] > MAX_ERRORS){
+				temp_ok &= ~(1<<i);
+			} else {
+				error_cnt[i]++;
+			}
+		} else {
+			error_cnt[i] = 0;
+			temp_ok |= 1<<i;
+		}
+	}
+	
+	find_1wire();
+
+	_1WireInit();
+	_1WireWriteByte(0xcc);
+	_1WireWriteBytePR(0x44);
+	atomic_set_uint(&timers.owire, ms(4000));
+}
+

ds18b20.h

@@ -0,0 +1,7 @@
+
+extern unsigned char temp_ok;
+extern signed int temps[MAX_SENSOR_NUM];
+
+unsigned char find_1wire(void);
+void gettemp(void);
+

gtext.c

@@ -0,0 +1,263 @@
+#include <avr/io.h>
+#include "sed1335.h"
+#include "gtext.h"
+#include <avr/pgmspace.h>
+#include <util/delay.h>
+#include <string.h>
+
+unsigned char blackbg = 0; //0=bez tła, 1=tło z paskami, 2=tło jednolite
+unsigned char color = 0x3; //kolor tekstu
+
+PROGMEM unsigned char const FontTable[][13] = {
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  }, //  
+	{0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00,  }, // ! //
+	{0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  }, // "
+	{0x00, 0x12, 0x12, 0x12, 0x7e, 0x24, 0x24, 0x7e, 0x48, 0x48, 0x48, 0x00, 0x00,  }, // #
+	{0x00, 0x08, 0x3e, 0x49, 0x48, 0x38, 0x0e, 0x09, 0x49, 0x3e, 0x08, 0x00, 0x00,  }, // $
+	{0x00, 0x31, 0x4a, 0x4a, 0x34, 0x08, 0x08, 0x16, 0x29, 0x29, 0x46, 0x00, 0x00,  }, // %
+	{0x00, 0x1c, 0x22, 0x22, 0x22, 0x1c, 0x39, 0x45, 0x42, 0x46, 0x39, 0x00, 0x00,  }, // &
+	{0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  }, // '
+	{0x04, 0x08, 0x08, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x04, 0x00,  }, // (
+	{0x20, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x10, 0x10, 0x20, 0x00,  }, // )
+	{0x00, 0x00, 0x00, 0x08, 0x49, 0x2a, 0x1c, 0x2a, 0x49, 0x08, 0x00, 0x00, 0x00,  }, // *
+	{0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,  }, // + //
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0x18, 0x30,  }, // , //
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  }, // - //
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00,  }, // .
+	{0x00, 0x02, 0x02, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x40, 0x40, 0x00, 0x00,  }, // /
+	{0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00, 0x00,  }, // 0 //
+	{0x00, 0x38, 0x78, 0xd8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xfe, 0x00, 0x00,  }, // 1 //
+	{0x00, 0x7c, 0xc6, 0xc6, 0x06, 0x1c, 0x30, 0x60, 0xc0, 0xc0, 0xfe, 0x00, 0x00,  }, // 2 //
+	{0x00, 0x7c, 0xc6, 0xc6, 0x06, 0x3c, 0x06, 0x06, 0xc6, 0xc6, 0x7c, 0x00, 0x00,  }, // 3 //
+	{0x00, 0x0c, 0x1c, 0x3c, 0x6c, 0xcc, 0xcc, 0xff, 0x0c, 0x0c, 0x0c, 0x00, 0x00,  }, // 4 //
+	{0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0x06, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00,  }, // 5 //
+	{0x00, 0x3c, 0x60, 0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00,  }, // 6 //
+	{0x00, 0xfe, 0x06, 0x06, 0x0c, 0x0c, 0x0c, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,  }, // 7 //
+	{0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00,  }, // 8 //
+	{0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x06, 0x06, 0x0c, 0x78, 0x00, 0x00,  }, // 9 //
+	{0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,  }, // :
+	{0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x08, 0x10, 0x00,  }, // ;
+	{0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x00, 0x00,  }, // < //
+	{0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00,  }, // =
+	{0x00, 0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, 0x00,  }, // >
+	{0x00, 0x3c, 0x42, 0x42, 0x02, 0x04, 0x08, 0x08, 0x00, 0x08, 0x08, 0x00, 0x00,  }, // ?
+	{0x00, 0x1c, 0x22, 0x4a, 0x56, 0x52, 0x52, 0x52, 0x4e, 0x20, 0x1e, 0x00, 0x00,  }, // @
+	{0x00, 0x38, 0x6c, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00,  }, // A //
+	{0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0xfc, 0x00, 0x00,  }, // B //
+	{0x00, 0x7c, 0xc6, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc6, 0xc6, 0x7c, 0x00, 0x00,  }, // C //
+	{0x00, 0xf8, 0xcc, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xcc, 0xf8, 0x00, 0x00,  }, // D //
+	{0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00,  }, // E //
+	{0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00,  }, // F //
+	{0x00, 0x7c, 0xc6, 0xc6, 0xc0, 0xc0, 0xce, 0xc6, 0xc6, 0xc6, 0x3a, 0x00, 0x00,  }, // G //
+	{0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00,  }, // H //
+	{0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x00, 0x00,  }, // I //
+	{0x00, 0x1e, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x38, 0x00, 0x00,  }, // J //
+	{0x00, 0xc6, 0xcc, 0xd8, 0xf0, 0xe0, 0xe0, 0xf0, 0xd8, 0xcc, 0xc6, 0x00, 0x00,  }, // K //
+	{0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00,  }, // L //
+	{0x00, 0xc6, 0xee, 0xd6, 0xd6, 0xd6, 0xd6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00,  }, // M //
+	{0x00, 0xc6, 0xe6, 0xe6, 0xf6, 0xf6, 0xde, 0xde, 0xce, 0xce, 0xc6, 0x00, 0x00,  }, // N //
+	{0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00,  }, // O //
+	{0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00,  }, // P //
+	{0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xda, 0xe6, 0x7c, 0x03, 0x00,  }, // Q //
+	{0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xfc, 0xd8, 0xcc, 0xcc, 0xc6, 0xc6, 0x00, 0x00,  }, // R //
+	{0x00, 0x7c, 0xc6, 0xc6, 0xc0, 0x30, 0x0c, 0x06, 0xc6, 0xc6, 0x7c, 0x00, 0x00,  }, // S //
+	{0x00, 0xfe, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,  }, // T //
+	{0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00,  }, // U //
+	{0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x3c, 0x18, 0x18, 0x00, 0x00,  }, // V //
+	{0x00, 0xc6, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xd6, 0xee, 0xee, 0xc6, 0x00, 0x00,  }, // W //
+	{0x00, 0xc6, 0xc6, 0x6c, 0x6c, 0x38, 0x38, 0x6c, 0x6c, 0xc6, 0xc6, 0x00, 0x00,  }, // X //
+	{0x00, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,  }, // Y //
+	{0x00, 0xfe, 0x06, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xc0, 0xfe, 0x00, 0x00,  }, // Z //
+	{0x0e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x0e, 0x00,  }, // [
+	{0x00, 0xc0, 0xc0, 0xe0, 0x30, 0x30, 0x18, 0x18, 0x0c, 0x06, 0x06, 0x00, 0x00,  }, // odwrotny /
+	{0x70, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x70, 0x00,  }, // ]
+	{0x18, 0x3c, 0x7e, 0xdb, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,  }, // ^ ↑
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00,  }, // _
+	{0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  }, // `
+	{0x00, 0x00, 0x00, 0x7c, 0xc6, 0x06, 0x3e, 0xc6, 0xc6, 0xc6, 0x3a, 0x00, 0x00,  }, // a //
+	{0xc0, 0xc0, 0xc0, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xe6, 0xdc, 0x00, 0x00,  }, // b //
+	{0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00,  }, // c //
+	{0x06, 0x06, 0x06, 0x3e, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x3a, 0x00, 0x00,  }, // d //
+	{0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00,  }, // e //
+	{0x1c, 0x30, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00,  }, // f //
+	{0x00, 0x00, 0x06, 0x3a, 0xcc, 0xcc, 0xcc, 0x38, 0x60, 0xfc, 0xc6, 0xc6, 0x7c,  }, // g //
+	{0xc0, 0xc0, 0xc0, 0xfc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00,  }, // h //
+	{0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00,  }, // i //
+	{0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xd8, 0x70,  }, // j //
+	{0xc0, 0xc0, 0xc0, 0xcc, 0xd8, 0xf0, 0xe0, 0xf0, 0xd8, 0xcc, 0xc6, 0x00, 0x00,  }, // k //
+	{0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x0e, 0x00, 0x00,  }, // l //
+	{0x00, 0x00, 0x00, 0xec, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0x00, 0x00,  }, // m //
+	{0x00, 0x00, 0x00, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00,  }, // n //
+	{0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00,  }, // o //
+	{0x00, 0x00, 0x00, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xe6, 0xdc, 0xc0, 0xc0,  }, // p //
+	{0x00, 0x00, 0x00, 0x3a, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x3e, 0x06, 0x06,  }, // q //
+	{0x00, 0x00, 0x00, 0xdc, 0xe6, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00,  }, // r //
+	{0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0x30, 0x0c, 0x06, 0xc6, 0x7c, 0x00, 0x00,  }, // s //
+	{0x00, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x1c, 0x00, 0x00,  }, // t //
+	{0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xce, 0x76, 0x00, 0x00,  }, // u //
+	{0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0x6c, 0x6c, 0x6c, 0x38, 0x38, 0x00, 0x00,  }, // v //
+	{0x00, 0x00, 0x00, 0xc6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0x6c, 0x00, 0x00,  }, // w //
+	{0x00, 0x00, 0x00, 0xc6, 0xc6, 0x6c, 0x38, 0x38, 0x6c, 0xc6, 0xc6, 0x00, 0x00,  }, // x //
+	{0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x66, 0x3e, 0x06, 0x0e, 0xfc,  }, // y //
+	{0x00, 0x00, 0x00, 0xfe, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xfe, 0x00, 0x00,  }, // z //
+	{0x00, 0x38, 0x6c, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  }, // 0x7b ° //
+	{0x7C, 0x42, 0x42, 0x7C, 0x48, 0x44, 0x42, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00,  }, // 0x7c małe R na górze
+	{0xff, 0xff, 0xff, 0x7e, 0x7e, 0x3c, 0x3c, 0x18, 0x18, 0x00, 0x3c, 0x3c, 0x3c,  }, // 0x7d brzydki wykrzyknik
+	{0x00, 0x00, 0x00, 0x7c, 0xc6, 0x06, 0x3e, 0xc6, 0xc6, 0xc6, 0x3a, 0x18, 0x0c,  }, // 0x7e ą //
+	{0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x18, 0x0c,  }, // 0x7f ę //
+	{0x00, 0x38, 0x18, 0x18, 0x18, 0x1e, 0x78, 0x18, 0x18, 0x18, 0x0e, 0x00, 0x00,  }, // 0x80 ł //
+	{0x0c, 0x18, 0x00, 0x7c, 0xc6, 0xc0, 0x30, 0x0c, 0x06, 0xc6, 0x7c, 0x00, 0x00,  }, // 0x81 ś //
+	{0x0c, 0x18, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00,  }, // 0x82 ó //
+	{0x18, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00,  }, // 0x83 Ó //
+	{0x00, 0x00, 0x00, 0xff, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xff, 0x00, 0x00,  }, // 0x84 ramka pusta
+	{0x00, 0x00, 0x00, 0xff, 0x83, 0x85, 0x85, 0xc9, 0xa9, 0x91, 0xff, 0x00, 0x00,  }, // 0x85 ramka z ptaszkiem
+	{0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xdb, 0x7e, 0x3c, 0x18,  }, // 0x86 ↓
+};
+
+void GLCD_Clear(void){ //zastępuję funkcję z sed1335.c
+	unsigned int i;
+
+	GLCD_SetCursorAddress(SED1335_GRAPHICSTART);
+	GLCD_WriteCommand(SED1335_MWRITE);
+	for(i = 0; i < SED1335_GRAPHICSIZE; i++)
+		GLCD_WriteData(0x00);
+
+	GLCD_SetCursorAddress(SED1335_TGRAPHICSTART);
+	GLCD_WriteCommand(SED1335_MWRITE);
+	for(i = 0; i < SED1335_GRAPHICSIZE; i++)
+		GLCD_WriteData(0x00);
+		
+	GLCD_WriteCommand(SED1335_DISP_ON);
+	GLCD_WriteData(SED1335_FLASH);
+}
+
+void GLCD_TLGoTo(unsigned int x, unsigned int y){
+	GLCD_SetCursorAddress(SED1335_TGRAPHICSTART + y*80 + x*2);
+}
+
+static unsigned char cur_x, cur_y;
+
+void GLCD_GraphicGoTo_T(unsigned int x, unsigned int y){
+	GLCD_SetCursorAddress(SED1335_GRAPHICSTART + y*80 + x*2);
+}
+
+void grayscale(const unsigned char * const c_ptr){ //zamień dane z FontTable na takie do wysłania do lcd, i wyślij
+	unsigned char x;
+	unsigned char i,j;
+	char c = pgm_read_byte(c_ptr);
+	for(i=0;i<2;i++){
+		x = 0;
+		for(j=0;j<4;j++){
+			x <<= 2;
+			if(c&128){
+				x |= color;
+			}
+			c <<= 1;
+		}
+		GLCD_WriteData(x);
+	}
+}
+
+/*inline static void ch_pos(void){
+	if(cur_x>X_MAX){
+		cur_x = 0;
+		if(++cur_y>Y_MAX) cur_y = 0;
+	}
+}*/
+#define ch_pos() if(cur_x>X_MAX){ cur_x=0; if(++cur_y>Y_MAX) cur_y=0; }
+
+void cursor(unsigned char x, unsigned char y){ //ustaw kursor tekstowy
+	if(x>X_MAX) x=X_MAX;
+	if(y>Y_MAX) y=Y_MAX;
+	cur_x = x;
+	cur_y = y;
+}
+
+void background(unsigned char cnt){ //rysowanie tła - do reszty funkcji
+	unsigned char i, tmp_cnt, tmp_data;
+	for(i=0;i<13;i++){
+		tmp_data = blackbg?((i==0||i==12)&&blackbg!=2?0xaa:0x55):0;
+		tmp_cnt = cnt;
+		GLCD_GraphicGoTo_T(cur_x, cur_y*15+i);
+		GLCD_WriteCommand(SED1335_MWRITE);
+		while(tmp_cnt--){
+			GLCD_WriteData(tmp_data);
+			GLCD_WriteData(tmp_data);
+		}
+	}
+	GLCD_WriteCommand(SED1335_DISP_ON);
+	GLCD_WriteData(SED1335_FLASH);
+}
+
+void puttext_P(const char *text){ //wypisz tekst z flasha
+	unsigned char i=0;
+	static char buffer[X_MAX+1];
+	while((buffer[i++] = pgm_read_byte(text++)));
+	puttext(buffer);
+}
+
+void puttext(const char *text){ //wypisz tekst z ramu
+	register unsigned char cnt=0, i, j;
+	cnt = strlen(text);
+
+	background(cnt);
+
+	for(i=0;i<13;i++){
+		GLCD_TLGoTo(cur_x, cur_y*15+i);
+		GLCD_WriteCommand(SED1335_MWRITE);
+		for(j=0;j<cnt;j++){
+			grayscale(&FontTable[text[j]-' '][i]);
+		}
+	}
+	cur_x += cnt;
+	ch_pos();
+	GLCD_WriteCommand(SED1335_DISP_ON);
+	GLCD_WriteData(SED1335_FLASH);
+}
+
+void putchar(char c){ //wypisz jeden znak
+	unsigned char i;
+	background(1);
+	for(i=0; i<13; i++){
+		GLCD_TLGoTo(cur_x, cur_y*15+i);
+		GLCD_WriteCommand(SED1335_MWRITE);
+		grayscale(&FontTable[c-' '][i]);
+	}
+	++cur_x;
+	ch_pos();
+	GLCD_WriteCommand(SED1335_DISP_ON);
+	GLCD_WriteData(SED1335_FLASH);
+}
+
+void clear_to(unsigned char pos){ //wyczyść do pozycji
+	unsigned char i, j, cnt;
+	cnt = pos-cur_x+1; //ilość znaków do wyczyszczenia
+
+	background(cnt);
+
+	for(i=0;i<13;i++){
+		GLCD_TLGoTo(cur_x, cur_y*15+i);
+		GLCD_WriteCommand(SED1335_MWRITE);
+		for(j=0;j<cnt;j++){
+			GLCD_WriteData(0); //dwa razy bo 2bpp, stąd dwa bajty na znak
+			GLCD_WriteData(0);
+		}
+	}
+	if(pos > X_MAX){
+		cur_x = 0;
+		if(++cur_y > Y_MAX) cur_y = 0;
+	} else {
+		cur_x = pos+1;
+	}
+	GLCD_WriteCommand(SED1335_DISP_ON);
+	GLCD_WriteData(SED1335_FLASH);
+}
+/*
+void clearline(void){ //wyczyść do końca linii - nie używać - zamiast tego jest makro
+	while(cur_x <= X_MAX){
+		putchar(' ');
+		if(!cur_x) break;
+	}
+}*/
+
+

gtext.h

@@ -0,0 +1,19 @@
+void cursor(unsigned char x, unsigned char y);
+void putchar(char c);
+void puttext(const char *text);
+void puttext_P(const char *text);
+//void clearline(void);
+void putchar_bg(char c);
+void clearfield(void);
+void clearline_bg(void);
+void puttext_bg_P(const char *text);
+void puttext_bg(const char *text);
+void clear_to(unsigned char pos);
+
+extern unsigned char blackbg, color;
+
+#define X_MAX 28
+#define Y_MAX 12
+
+#define clearline() clear_to(X_MAX)
+

main.c

@@ -0,0 +1,77 @@
+#include <avr/io.h>
+#include <util/delay.h>
+#include <avr/pgmspace.h>
+#include "main.h"
+#include "1wire.h"
+
+#include "gtext.h"
+#include "sed1335.h"
+#include "ds18b20.h"
+
+#include "display.h"
+
+volatile struct timers timers;
+
+unsigned char getkey(void){
+	static unsigned char old;
+	unsigned char key;
+	DDRA = 0;
+	PORTA = 0xff;
+	DDRC |= _BV(PC7);
+	_delay_ms(2);
+	key = ~PINA;
+	DDRC &= ~_BV(PC7);
+	PORTA = 0;
+	DDRA = 0xff;
+	if(key == old) return 0;
+	old = key;
+	return key;
+}
+
+void main(void){
+	unsigned char i=0;
+/*	unsigned char state = STATE_DEFAULT;
+	unsigned char oldstate = state;*/
+	
+	
+	OCR2A = 250; // 16ms
+	TCCR2A = _BV(WGM21);
+	TCCR2B = _BV(CS22) | _BV(CS21) | _BV(CS20);
+	TIMSK2 = _BV(OCIE2A);
+	sei();
+
+	PORTC &= _BV(PC7);
+	DDRB |= _BV(PB2);
+	
+	GLCD_Initialize();
+	GLCD_Clear();
+	for(;;){
+		_delay_ms(100);
+		if(i = getkey()){
+			cursor(0,0);
+			disp_num(i);
+			clearline();
+		}
+/*		gettemp();
+		control();
+		state = state_processors[state](state);
+		if(oldstate != state){
+			GLCD_Clear();
+			settings_update = 1;
+		}
+		oldstate = state; 
+		send_595(&led, 1);*/
+	}
+}
+
+ISR(TIMER2_COMPA_vect){ // 16ms
+	unsigned int *volatile ctimer;
+	unsigned char i;
+	
+	for(i=0; i<sizeof(timers)/sizeof(unsigned int); i++){
+		ctimer = ((unsigned int *)&timers) + i;
+		if(*ctimer)
+			(*ctimer)--;
+	}
+}
+

main.h

@@ -0,0 +1,29 @@
+#include <avr/interrupt.h>
+
+#define MAX_SENSOR_NUM 1
+
+#define KEY_ESC	128
+#define KEY_UP	32
+#define KEY_DOWN	16
+#define KEY_LEFT	64
+#define KEY_RIGHT	8
+#define KEY_1	1
+#define KEY_2	2
+#define KEY_OK	4
+
+#define ms(x) ((unsigned int)x/16)
+
+struct timers {
+	unsigned int tick;
+	unsigned int owire;
+};
+
+extern volatile struct timers timers;
+
+static inline void atomic_set_uint(volatile unsigned int *volatile data, unsigned int value) __attribute__((always_inline));
+static inline void atomic_set_uint(volatile unsigned int *volatile data, unsigned int value){
+	cli();
+	*data = value;
+	sei();
+}
+

sed1335.c

@@ -0,0 +1,229 @@
+#include <util/delay.h>
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <util/delay.h>
+#include <avr/interrupt.h>
+#include <avr/wdt.h>
+#include "sed1335.h"
+
+//config data is set in sed1335.h
+
+void GLCD_Initialize(void){
+	GLCD_InitializePorts();
+
+	GLCD_HardReset();
+
+	GLCD_WriteCommand(SED1335_SYSTEM_SET); 
+	_delay_ms(10);
+	GLCD_WriteData(SED1335_SYS_P1);
+	GLCD_WriteData(SED1335_SYS_P2);	
+	GLCD_WriteData(SED1335_FY);
+	GLCD_WriteData(SED1335_CR);	
+	GLCD_WriteData(SED1335_TCR);
+	GLCD_WriteData(SED1335_LF);	
+	GLCD_WriteData(SED1335_AP & 0xff);
+	GLCD_WriteData(SED1335_AP >> 8);	
+
+	GLCD_WriteCommand(SED1335_SCROLL);   
+	GLCD_WriteData(SED1335_SAD1 & 0xff);		
+	GLCD_WriteData(SED1335_SAD1 >> 8);		
+	GLCD_WriteData(SED1335_SL1);		
+	GLCD_WriteData(SED1335_SAD2 & 0xff);		
+	GLCD_WriteData(SED1335_SAD2 >> 8);		
+	GLCD_WriteData(SED1335_SL2);		
+	GLCD_WriteData(SED1335_SAD3 & 0xff);		
+	GLCD_WriteData(SED1335_SAD3 >> 8); 
+	GLCD_WriteData(SED1335_SAD4 & 0xff);		
+	GLCD_WriteData(SED1335_SAD4 >> 8);		
+	
+	GLCD_WriteCommand(SED1335_CSRFORM);
+	GLCD_WriteData(SED1335_CRX);		
+	GLCD_WriteData(SED1335_CSRF_P2);		
+	
+	GLCD_WriteCommand(SED1335_CGRAM_ADR);
+	GLCD_WriteData(SED1335_SAG & 0xff);
+	GLCD_WriteData(SED1335_SAG >> 8);
+	
+	GLCD_WriteCommand(SED1335_CSRDIR_R);      
+
+	GLCD_WriteCommand(SED1335_HDOT_SCR);       
+	GLCD_WriteData(SED1335_SCRD);			
+	
+	GLCD_WriteCommand(SED1335_OVLAY);            
+	GLCD_WriteData(SED1335_OVLAY_P1);
+
+	GLCD_WriteCommand(SED1335_GRAYSCALE);		
+	GLCD_WriteData(SED1335_BPP);
+			
+	GLCD_WriteCommand(SED1335_DISP_ON);
+	GLCD_WriteData(SED1335_FLASH);
+
+	GLCD_Clear();
+}
+
+//internal functions
+
+void GLCD_InitializePorts(void){
+	SED1335_DATA_DIR = 0xFF;
+#ifdef SED1335_CS
+	SED1335_CONTROL_PORT |= SED1335_CS;
+	SED1335_CONTROL_DIR |= SED1335_CS;
+#endif
+	SED1335_CONTROL_PORT |= (SED1335_WR 
+#ifdef SED1335_RD
+		| SED1335_RD
+#endif
+		| SED1335_RES); 
+	SED1335_CONTROL_DIR |= (SED1335_A0 | SED1335_WR
+#ifdef SED1335_RD
+		| SED1335_RD
+#endif
+		| SED1335_RES); 
+	SED1335_RST_PORT |= SED1335_RES;
+	SED1335_RST_DIR |= SED1335_RES;
+}
+
+void GLCD_WriteData(unsigned char dataToWrite){
+	cli();
+	SED1335_DATA_PORT = dataToWrite;
+#ifdef SED1335_CS
+	SED1335_CONTROL_PORT &= ~SED1335_CS;
+#endif
+	SED1335_CONTROL_PORT &= ~SED1335_WR;
+	asm("nop");
+	SED1335_CONTROL_PORT |= SED1335_WR;
+#ifdef SED1335_CS
+	SED1335_CONTROL_PORT |= SED1335_CS;
+#endif
+	sei();
+}
+
+void GLCD_WriteCommand(unsigned char commandToWrite){
+	SED1335_CONTROL_PORT |= SED1335_A0;
+	cli();
+	SED1335_DATA_PORT = commandToWrite;
+#ifdef SED1335_CS
+	SED1335_CONTROL_PORT &= ~SED1335_CS;
+#endif
+	SED1335_CONTROL_PORT &= ~SED1335_WR;
+	asm("nop");
+	SED1335_CONTROL_PORT |= SED1335_WR;
+#ifdef SED1335_CS
+	SED1335_CONTROL_PORT |= SED1335_CS;
+#endif
+	sei();
+	SED1335_CONTROL_PORT &= ~SED1335_A0;
+}
+
+/*unsigned char GLCD_ReadData(void){
+	unsigned char tmp;
+#ifdef SED1335_CS
+	SED1335_CONTROL_PORT &= ~SED1335_CS;
+#endif
+	SED1335_CONTROL_PORT |= SED1335_A0;
+	cli();
+	SED1335_DATA_DIR = 0x00;
+	SED1335_CONTROL_PORT &= ~SED1335_RD;
+	asm("nop");
+	tmp =  SED1335_DATA_PIN;
+	SED1335_CONTROL_PORT |= SED1335_RD;
+#ifdef SED1335_CS
+	SED1335_CONTROL_PORT |= SED1335_CS;
+#endif
+	sei();
+	SED1335_CONTROL_PORT &= ~SED1335_A0;
+	return tmp;
+}*/
+
+void GLCD_HardReset(void){
+	wdt_reset();
+	_delay_ms(150);
+	wdt_reset();
+	SED1335_RST_PORT &= ~(SED1335_RES);
+	_delay_ms(20);
+	SED1335_RST_PORT |= (SED1335_RES);
+	_delay_ms(20);
+	wdt_reset();
+}
+
+//external LCD access functions
+
+/*void GLCD_Clear(void){ //używam swojej w gtext.c
+	GLCD_ClearText();
+	GLCD_ClearGraphic();
+}*/
+
+/*void GLCD_SetPixel(unsigned int x,unsigned int y, int color){ //nietestowane!
+	unsigned char tmp = 0;
+	unsigned int address = SED1335_GRAPHICSTART + (40 * y) + (x/8); 
+	GLCD_SetCursorAddress(address);
+
+	GLCD_WriteCommand(SED1335_MREAD);
+	tmp = GLCD_ReadData();
+
+	if(color)
+	  tmp |= (1 << (SED1335_FX - (x % 8)));
+	else
+	  tmp &= ~(1 << (SED1335_FX - (x % 8)));
+
+	GLCD_SetCursorAddress(address);
+	GLCD_WriteCommand(SED1335_MWRITE);
+	GLCD_WriteData(tmp);
+}*/
+
+// funkcje do trybu tekstowego - nie używam
+/*void GLCD_WriteText(char * tekst){
+	GLCD_WriteCommand(SED1335_MWRITE);
+	while(*tekst)
+		GLCD_WriteData(*tekst++);
+}*/
+
+/*void GLCD_WriteTextP(char * tekst){
+	GLCD_WriteCommand(SED1335_MWRITE);
+	while(pgm_read_byte(tekst))
+		GLCD_WriteData(GLCD_ReadByteFromROMMemory(tekst++));
+}*/
+
+/*void GLCD_TextGoTo(unsigned char x, unsigned char y){
+	GLCD_SetCursorAddress((y * 40) + x);
+}*/
+
+/*void GLCD_ClearText(void){
+	int i;
+	GLCD_TextGoTo(0,0);
+	GLCD_WriteCommand(SED1335_MWRITE);
+	for(i = 0; i < 1200; i++)
+		GLCD_WriteData(' ');
+}*/
+
+void GLCD_SetCursorAddress(unsigned int address){
+	GLCD_WriteCommand(SED1335_CSRW);
+	GLCD_WriteData((unsigned char)(address & 0xFF));
+	GLCD_WriteData((unsigned char)(address >> 8));
+}
+
+// funkcje do trybu graficznego - używam własnych w gtext.c
+/*void GLCD_GraphicGoTo(unsigned int x, unsigned int y){
+	GLCD_SetCursorAddress(SED1335_GRAPHICSTART + (y * 80) + x*2);
+}*/
+
+/*void GLCD_ClearGraphic(void){
+	unsigned int i;
+
+	GLCD_SetCursorAddress(SED1335_GRAPHICSTART);
+	GLCD_WriteCommand(SED1335_MWRITE);
+	for(i = 0; i < SED1335_GRAPHICSIZE; i++) //zweryfikuj przed użyciem, czy dobra strona!!!
+		GLCD_WriteData(0x00);
+	clearbg();
+}*/
+
+/*void GLCD_Bitmap(char * bmp, int x, int y, int width, int height){ //nietestowane
+	unsigned int i, j;
+	for(i = 0; i < height ; i++){
+		GLCD_GraphicGoTo(x, y+i);
+		GLCD_WriteCommand(SED1335_MWRITE);
+		for(j = 0; j < width/8; j++)
+			GLCD_WriteData(pgm_read_byte(bmp+j+(40*i)));
+	}
+}*/
+

sed1335.h

@@ -0,0 +1,101 @@
+// value definitions, don't change this
+#define 	SED1335_SYSTEM_SET   	0x40
+#define 	SED1335_SLEEP_IN   		0x53
+#define 	SED1335_DISP_OFF   		0x58
+#define 	SED1335_DISP_ON   		0x59
+#define 	SED1335_SCROLL   		0x44
+#define 	SED1335_CSRFORM   		0x5d
+#define 	SED1335_CGRAM_ADR   	0x5c
+#define 	SED1335_CSRDIR_U   		0x4e
+#define 	SED1335_CSRDIR_D   		0x4f
+#define 	SED1335_CSRDIR_L   		0x4d
+#define 	SED1335_CSRDIR_R   		0x4c
+#define 	SED1335_HDOT_SCR   		0x5a
+#define 	SED1335_OVLAY   		0x5b
+#define 	SED1335_CSRW   			0x46
+#define 	SED1335_CSRR   			0x47
+#define 	SED1335_MWRITE   		0x42
+#define 	SED1335_MREAD   		0x43
+#define		SED1335_GRAYSCALE		0x60
+#define		SED1335_OFF				0x0
+#define		SED1335_ON				0x1
+#define		SED1335_FLASH_2HZ		0x2
+#define		SED1335_FLASH_16HZ		0x3
+
+//pin/port definitions
+#define SED1335_DATA_PORT		PORTA
+#define SED1335_DATA_DIR		DDRA
+#define SED1335_DATA_PIN		PINA
+
+#define SED1335_CONTROL_PORT	PORTB
+#define SED1335_CONTROL_DIR		DDRB
+#define	SED1335_CONTROL_PIN		PINB
+#define SED1335_RST_PORT		PORTD
+#define SED1335_RST_DIR			DDRD
+
+#define SED1335_A0				(1 << PB0)
+#define SED1335_WR				(1 << PB1)
+#undef SED1335_RD
+#undef SED1335_CS
+#define SED1335_RES				(1 << PD0)
+
+// LCD config values
+#define 	SED1335_M0   			0		//character generator select, 0=cgrom, 1=cgram
+#define 	SED1335_M2   			0		//character height, 0=8px, 1=16px
+#define 	SED1335_WS   			0		//panel drive select, 0=single, 1=dual
+#define 	SED1335_IV   			1		//screen origin compensation, 1=shift text down by 1px
+#define 	SED1335_FX   			7		//horizontal size of characters minus one
+#define 	SED1335_FY   			7		//vertical size of characters minus one
+#define 	SED1335_WF   			1		//ac drive waveform period, 0=16-line ac drive, 1=two-frame ac drive
+#define 	SED1335_CR   			59		//character bytes per row minus one
+#define 	SED1335_TCR   			61		//total character bytes per row >= CR+2
+#define 	SED1335_LF   			159		//frame height minus one
+#define 	SED1335_AP   			80		//horizontal address range -----------tu chyba powinno być 60, ale nie działa!
+#define 	SED1335_CRX   			0x04	//cursor width, pixels minus one
+#define 	SED1335_CRY   			0x07	//cursor height, pixels minus one
+#define 	SED1335_CM   			0		//cursor mode, 0=underscore, 1=block
+#define 	SED1335_MX   			0		//layer composition method, 0=or, 1=xor, 2=and
+#define 	SED1335_DM1   			1		//display mode for screen block 3, 0=text, 1=graphic
+#define 	SED1335_DM0   			1		//display mode for screen block 1, 0=text, 1=graphic
+#define 	SED1335_OV   			1		//3 layer overlay select, 0=two layers, 1=three layers
+#define 	SED1335_SAG   			0x7000	//character generator start address
+#define 	SED1335_SCRD   			0		//horizontal pixel scroll
+#define 	SED1335_FLASH   		(SED1335_OFF | (SED1335_OFF<<2) | (SED1335_ON<<4) | (SED1335_ON<<6)) //off-on-flash; cursor, sad1, sad2, sad3
+//#define 	SED1335_TEXTSIZE   		((SED1335_SAD2H << 8) + SED1335_SAD2L)
+#define		SED1335_BPP				1		//bits per pixel, 0=1, 1=2, 2=4
+
+#define 	SED1335_GRAPHICSIZE		((long int)(SED1335_LF+1)*SED1335_AP)
+
+#define 	SED1335_SAD1	   		0x0000	//first display memory page addr
+#define 	SED1335_SL1   			SED1335_LF	//size of block screen 1 in lines minus one
+#define 	SED1335_SAD2	   		0x0000	//second display memory page addr
+#define 	SED1335_SL2   			SED1335_LF	//size of block screen 2 in lines minus one
+#define 	SED1335_SAD3   			(SED1335_SAD2 + SED1335_GRAPHICSIZE)	//third display memory page addr
+#define 	SED1335_SAD4   			0x0000	//fourth display memory page addr
+
+#define		SED1335_GRAPHICSTART	SED1335_SAD2
+#define		SED1335_TGRAPHICSTART	SED1335_SAD3 //używane przez gtext.c; jak ustawiłem OV=0 i używałem strony 1 zamiast 3, były dziwne zjawiska przy zapisie do GRAM na zielonych wyświetlaczach
+
+//#define 	SED1335_GRAPHICSIZE   	((SED1335_SL2+1) * (SED1335_SCR_WIDTH+1))>>3
+//#define 	SED1335_MEM_END   		10800 /// ????
+#define 	SED1335_SYS_P1   		0x00 | (SED1335_IV << 5) | (1 << 4) | (SED1335_WS << 3) | (SED1335_M2 << 2) | SED1335_M0
+#define 	SED1335_SYS_P2   		0x00 | (SED1335_WF << 7) | SED1335_FX
+#define 	SED1335_CSRF_P2   		0x00 | (SED1335_CM << 7) | SED1335_CRY
+#define 	SED1335_OVLAY_P1   		0x00 | (SED1335_OV << 4) | (SED1335_DM0 << 2) | (SED1335_DM1 << 3) | SED1335_MX
+
+void GLCD_Initialize(void);
+void GLCD_Clear(void);
+void GLCD_WriteCommand(unsigned char);
+void GLCD_WriteData(unsigned char);
+unsigned char GLCD_ReadData(void);
+void GLCD_InitializePorts(void);
+void GLCD_ClearText(void);
+void GLCD_ClearGraphic(void);
+void GLCD_TextGoTo(unsigned char, unsigned char);
+void GLCD_WriteText(char *);
+void GLCD_SetPixel(unsigned int x,unsigned int y, int color);
+void GLCD_SetCursorAddress(unsigned int address);
+void GLCD_GraphicGoTo(unsigned int x, unsigned int y);
+void GLCD_Bitmap(char * bmp, int x, int y, int dx, int dy);
+void GLCD_HardReset(void);
+