Elektroda.pl
Elektroda.pl
X
Elektroda.pl
Advanced Search
Elektroda.pl
Please add exception to AdBlock for elektroda.pl.
If you watch the ads, you support portal and users.

Wyświetlacz DMF6104-FW jak załadować do niego dane?[C]

gbr3 26 Apr 2008 14:25 49932 275
phoenixcontact
Reply | New topic
  • #91
    gbr3
    Level 15  
    Ok którą masz wersje płytki(może sam robiłeś?) ja miałem bardo duże problemy a okazało sie ze mam źle skonfigurowane porty w programie.Sprawdź czy nie ma zimnych lutów poprzedrapuj między nogami od scalaków.
    Jak możesz to podaj tą konfiguracje to sprawdze.
    Pozdro

    PS: Coś o zakłóceniach
    http://www.vitek.com.tw/technical/sed1335e.pdf
    dół 64 strony.
  • phoenixcontact
  • #92
    djkomprez
    Level 21  
    No wiec tak :P

    Pytka jest na pewno ok (wlasnej produkcji) bo z portem LPT działa
    bez problemów - wyświetla.

    Ale żeby to ustrojstwo zmusić do działania z atmega to kosmos ....

    A oto config (przepisany z programu działającego na lpt):

    Wyjsc
    Code: text Expand Select all Copy to clipboard
    

#define LCDG  PORTD                                     // PORT LINII STERUJACYCH
#define DLCDG DDRD
#define CS  6                                           // LINIA CHIP SELECT
#define A0  3                                           // LINIA WYBORU REJESTRU 0- REJESTR DANYCH, 1-REJESTR POLECEN
#define WR  5                                           // LINIA ZAPIS DANYCH DO SED1330F
#define RD  4                                           // LINIA ODCZYT DANYCH DO SED1330F
#define RES  7                                          // LINIA RESET AKTYWNY W STANIE NISKIM
//
#define SET_CS   LCDG |= _BV(CS)
#define CLR_CS   LCDG &= ~_BV(CS)
//
#define SET_A0  LCDG |= _BV(A0)
#define CLR_A0  LCDG &= ~_BV(A0)
//
#define SET_WR  LCDG |= _BV(WR)
#define CLR_WR  LCDG &= ~_BV(WR)
 //
#define SET_RD  LCDG |= _BV(RD)
#define CLR_RD  LCDG &= ~_BV(RD)
//
#define SET_RES  LCDG |= _BV(RES)               
#define CLR_RES  LCDG &= ~_BV(RES)

//----------------------------------------LINIE DANYCH-----------------------------------------------

#define LCDGd  PORTA                                     // PORT LINII DANYCH
#define DLCDGd DDRA
#define LCDG_PIN PINA


    LCD - tutaj chciałem zauważyć ze usunolem opóźnienia
    (w programie na lpt ich nie ma i max częstotliwość ostawiłem
    1mhz)

    Code: text Expand Select all Copy to clipboard
    
void wr_lcd_bus(unsigned char data)               // procedura zapisujaca 8-bitowa dana na magistrale
{
int temp = data;                                  // zaczytaj dana polecenie
LCDGd = temp;
SET_WR;                                          // WR ustaw w stan wysoki koniec zapisu
SET_CS;                                          // CS - chyp selekt w stan wysoki
LCDGd = 0x00;
}

void lcdg_init(void)                             // procedura inicjacji wyjsc sterujących
{

DLCDG = 0x7C;
LCDG = 0x7C;                                        // linie sterujace jako wyjsca
CLR_RES;                                         //stan niski na resecie sed1330f przez conajmniej 1ms
SET_RES;                                         //stan wysoki na resecie sed1330f przez conajmniej 1ms
LCDG = 0x7C;                                    //stan wysoki +5V na liniach sterujacych
}

void lcdg_write_data(unsigned char data)         // procedura zapisu danej do sterownika
{
DLCDGd = 0xFF;                                    // linie sterujace jako wyjsca
LCDGd = 0x00;                                     //stan niski 0V na liniach sterujacych
SET_RD;                                          // RD=1 - RD w stanie wysokim nie będziemy odczytywać danych
CLR_WR;
CLR_A0;                                          // A0=1 - zapis danej      poprawnie wg dokumentacji
CLR_CS;                                          // CS - chyp selekt w stan niski                                          //czekaj min 30 ns ( 62,5ns czeka)
CLR_WR;
wr_lcd_bus(data);                                // funkcja zapisu danej na magistrale
}


void lcdg_write_cmd(unsigned char cmd)         // procedura zapisu polecenia do sterownika
{
DLCDGd = 0xFF;                                    // linie sterujace jako wyjsca
LCDGd = 0x00;                                     //stan niski 0V na liniach sterujacych
SET_RD;                                          // RD=1 - RD w stanie wysokim nie będziemy odczytywać danych
CLR_WR;
SET_A0;                                          // A0=1 - zapis polecenia  poprawnie wg dokumentacji
CLR_CS;                                          // CS - chyp selekt w stan niski                                          //czekaj min 30 ns ( 62,5ns czeka)
wr_lcd_bus(cmd);                                 // funkcja zapisu danej na magistrale
}

unsigned char lcdg_read_status(void)                    // procedura odczytu flagi statusu
{
unsigned char stan;
stan=1;
DLCDGd = 0xBF;                                    // linie danych jako wejścia
LCDGd = 0x40;                                     // linie danych reagują na 0
SET_WR;                                          // WR=1 - WR w stanie wysokim nie będziemy zapisywac danych/komendy
SET_RD;
CLR_A0;                                          // A0=0 - odczyt statusu
CLR_CS;                                          // CS - chyp selekt w stan niski                                          //czekaj min 30 ns ( 62,5ns czeka)
CLR_RD;                                       
if(bit_is_clear(PINA,6))
{
stan=0;
}
SET_CS;                                          // CS w stan wysoki koniec obslugi SED
SET_RD;                                          // RD w stan wysoki odczytalismy dane
return stan;                       
}


void lcdg_init1(void)
{
lcdg_init();
lcdg_write_cmd(0x40);   //C
lcdg_write_data(0x38);  //P1 => DR, T/L, IV, 1, W/S, M2, M1, M0   
lcdg_write_data(0x87);  //P2=> WF 0 0 0 0 Fx2 Fx1 Fx0 szerokosc ramki znaku
lcdg_write_data(0x07);  //P3 => 0 0 0 0 Fy3 Fy2 Fy1 Fy0 wysokosc ramki znaku
lcdg_write_data(0x1F);  //P4 ilosc bajtow na linie 0x20=> 31 bajtow na linie  1F
lcdg_write_data(0x80);  //P5 TC/R = C/R+4 TC/R=32+4=36 22, 31
lcdg_write_data(0x7F);  //P6 L/F wysokość  calkowita ekranu 127 linie na panel  3f  7F
lcdg_write_data(0x80);  //P7
lcdg_write_data(0x00);  //P8   szerokość całkowita wyświetlacza 2 starsze bajty bajty
}

void lcd_wyswietlaj(void)
{
lcdg_write_cmd(0x44);   //C   SCROLL
lcdg_write_data(0x00);  //P1
lcdg_write_data(0x00);  //P2
lcdg_write_data(0x40);  //P3
lcdg_write_data(0x00);  //P4
lcdg_write_data(0x10);  //P5
lcdg_write_data(0x40);  //P6
lcdg_write_data(0x00);  //P7
lcdg_write_data(0x04);  //P8   
lcdg_write_data(0x00);  //P9
lcdg_write_data(0x30);  //P10

lcdg_write_cmd(0x5A);   //C    HDOT SCR
lcdg_write_data(0x00);  //P1

lcdg_write_cmd(0x5B);   //C    OVLAY
lcdg_write_data(0x01);  //P1=>   0 0 0 OV DM2 DM1 MX1 MX0   określa tyb wyświetlania

lcdg_write_cmd(0x58);   //C    DISP ON/OFF
lcdg_write_data(0x56);  //P1=>   FP5, FP4, FP3, FP2, FP1, FP0, FC1, FC0  włącza i wyłącza wyświetlanie
                     
lcdg_write_cmd(0x46);   //C    CSRW  ustawienie kursora w rządanym punkcie
lcdg_write_data(0x00);  //P1    współrzędna CSRL
lcdg_write_data(0x00);  //P2    współrzędna CSRH


lcdg_write_cmd(0x5D);   //C    CSR FROM  --
lcdg_write_data(0x04);  //P1  szerokość kursora w pikselach
lcdg_write_data(0x86);  //P2  wysokośc kursora w liniach

lcdg_write_cmd(0x59);   //C    DISP ON/OFF


lcdg_write_cmd(0x4C);   //C    CSR DIR
  • #93
    gbr3
    Level 15  
    Jakiego programu użyłeś do sterowania przez lpt ja kombinowałem z lcd studio ale cos mam nie tak z podłączeniem. Jakim cudem w lpt mam pin 0? Co w tym zrobić?
    Konfiguracja którą napisałeś nie działa pół wyświetlacza jest porozrzucane a pół w przypadkowe wzory
  • #94
    djkomprez
    Level 21  
    To nie ja pisałem tylko kumpel i obiektowo ... w WXdev

    A co do pin0 w lpt zobacz do ilu masz jeśli do 24 to traktuj 0 jako 1 ;)
  • #95
    djkomprez
    Level 21  
    Widzisz a mnie nawet nic nie pokazuje mam pusty ...
  • #96
    gbr3
    Level 15  
    Koło 21 wstawię działający program prawie bez zakłóceń kwarc przy sedzie 3 Mhz atmega 8 Mhz jeszcze nie trafiam w zapis pierwszego bajtu każdej linii więc pierwsze 8 pixeli ma zakłucenia przy odswieżaniu
    edit : Saper troche zmieniłem odczyt flagi :D
    Code: text Expand Select all Copy to clipboard
    
#include <avr/io.h>
#include <inttypes.h>
#include <avr/pgmspace.h>
#include <stdlib.h>

#include "makra.h"
#include "delay.c"
#include "sed1330.h"

// ------- Font libray inclusion ----------------
#ifdef SED_FUNCTS_STRINGS
	#include "font.h"
#endif
#include "sed1330text-font.h"
// ----------------------------------------------

#define sed_en_pulse() {\
			nop; \
			sed_set_en(); \
			nop; nop; nop; \
			nop; nop; nop; \
			sed_clr_en(); }


// This define witch mode sed is entered: graphic mode use 8bit char width, 
// but text-mode use 6bit char-width and 5bit of right side are not used in this mode.
uint8_t sed_mode=SED_MODE_NONE;
uint8_t sed_disp=SED_DISP1;

// ---- SEL1 = 0 => 8080 interface
void sed_data(uint8_t data) {

	while(sed_readBusy()==1){}
	DDR(SED_PORT_DATA) = 0xff;
	PORT(SED_PORT_DATA) = data;
	sed_clr_cs();
	sed_clr_A0();
	sed_clr_wr();
	// writting data to SED1330...
	asm("nop");
	sed_set_wr();
	sed_set_A0();
	sed_set_cs();
	
	
}

void sed_command(uint8_t cmd) {
	
	DDR(SED_PORT_DATA) = 0xff;
	PORT(SED_PORT_DATA) = cmd;
	sed_clr_cs();
	sed_set_A0();
	sed_clr_wr();
	// writting command....
	sed_set_wr();
	sed_set_cs();
		
}


uint8_t sed_read_memory(void) {
	// to wymaga poprawienia - nie poprawiam bo nie używam :)
	uint8_t t;
	// write command
	DDR(SED_PORT_DATA) = 0xff;
	PORT(SED_PORT_DATA) = SED_MEM_MREAD;
	sed_clr_cs();
	sed_set_A0();
	sed_set_rd();
	sed_clr_wr();
	
	sed_set_wr();
	
	DDR(SED_PORT_DATA) = 0x00;
	PORT(SED_PORT_DATA) = 0xff;
	sed_clr_rd();
	asm("nop");asm("nop");
	t = PIN(SED_PORT_DATA);
	
	t = PIN(SED_PORT_DATA);
	
	t = PIN(SED_PORT_DATA);
	
	t = PIN(SED_PORT_DATA);
	sed_set_rd();
	sed_set_cs();

	DDR(SED_PORT_DATA) = 0xff;
	PORT(SED_PORT_DATA) = 0xff;
	return t;
}


uint8_t sed_readBusy(void) {
	uint8_t t;
	DDR(SED_PORT_DATA) = 0x00;
	PORT(SED_PORT_DATA) = 0xff;
	sed_clr_cs();
	sed_clr_A0();
	sed_clr_rd();
	asm("nop");asm("nop");
	if(bit_is_clear(PINC,6)){t=0;}else{t=1;}
	sed_set_rd();
	sed_set_cs();
	DDR(SED_PORT_DATA) = 0xff;
	PORT(SED_PORT_DATA) = 0xff;
	return t;
} // */

void sed_initText(void) {	
	PORT(SED_PORT_DATA) = 0xff;
	DDR(SED_PORT_DATA) = 0xff;
	DDR(SED_PORT_CTRL) |= (1<<SED_PIN_RST | 1<<SED_PIN_CS | 1<<SED_PIN_RW | 1<<SED_PIN_EN | 1<<SED_PIN_A0);
	PORT(SED_PORT_CTRL) |= (1<<SED_PIN_RST | 1<<SED_PIN_CS | 1<<SED_PIN_RW | 1<<SED_PIN_EN | 1<<SED_PIN_A0);
	// Reset :)
	delay1ms(20);
	//sed_cs_control = SED_CS_CTRL_AUTO;
	sed_set_cs();
	sed_set_rd();
	sed_set_wr();
	
	sed_clr_rst();
	delay1ms(5); // min. 200us
	sed_set_rst();
	delay1ms(15);
	
	// SYSTEM SET
	sed_command(0x40); // system set
		// P1:
		//  *[0] M0  (0x01) - 0=Internal CG ROM, 1=External
		//  *[1] M1  (0x02) - 0=CG RAM1 32char, 1=64char CG RAM + CG RAM2
		//  *[2] M2  (0x04) - 0=8px char height , 1=16px char height <- External CG ROM
		//  *[3] W/S (0x08) - 0=Single panel LCD , 1=Dual panel LCD
		//  *[4] 1   (0x10) - 1= Always 1...
		//  *[5] IV  (0x20) - 0=Screen top-line correction , 1=No correction
		//  *[6] TL  (0x40) - 0=LCD Mode , 1=TV Mode (Only SED1336 ?)
		//  *[7] DR  (0x80) - 0=Normal , 1=Additional Shift clock cycles
		sed_data(0x08|0x10|0x20); // M2:M0=000, WS=1, IV=1, TL=0, DR=0
		// P2:
		//  *[2:0] FX (0x00...0x07) - Character field width + 1 (1...8)
		//  *[7] WF (0x80) - 0=16line AC Drive, 1=Two-frame AC Drive
			// CharsPerLine = 42 (6px char width when disp. width 256px)
		sed_data(0x80|5); // FX=7 (8px) or FX=5 (6px), WF=0 ::: FX >= DisplayWidth / CharsPerLine
		// P3:
		//  *[3:0] FY (0x00...0x0F) - Height in pixels of character + 1 (1...16)
		sed_data(7); // FY=7 (8px)
		// P4: 
		//  *[7:0] CR (0x00...0xEF - 0...239) - "Section 3.2.1.12" :::  CR=RND(FX / 8) * CharsPerLine
		#define SED_TEXT_CR 42
		sed_data(SED_TEXT_CR-1); // CR=32=0x20 for FX=7 ;  
		// P5:
		//  *[7:0] TCR (0x00...0xFF - 1...256) - must be: >= CR+4
		sed_data(SED_TEXT_CR+4); // P5: TCR=36
		// P6:
		//  *[7:0] LF (0x00...0xFF) - Height in lines of frame, height=LF+1
		sed_data(127); // LF=63+1=64
		// P7 & P8 - AP - horizontal address range = 256 = 0x0100 => [15:8-7:0] 0x01-0x00
		//  *[15:0] AP - horiontal address range of the virtual screen (same as CR??)
		sed_data(SED_TEXT_CR); // P7 - AP Low
		sed_data(0); // P8 - AP High
	
	// Memory map:
	// Hint: Display 1 - upper panel; Display 2 - lower panel
	// SAD1 :> dispaly 1, Layer 1 ( TEXT )
	// SAD3 :> display 2, Layer 1 ( TEXT )
	// SAD2 :> display 1, Layer 2 ( Graphic ) ; 64 rows, 256cols = 16384 / 8bits = 2048bytes per panel
	// SAD4 :> display 2, Layer 2 ( Graphic )
	sed_command(0x44); // Scroll
		// P1:P2 = SAD1 L:H
		sed_data(SED_SAD1L); // P1
		sed_data(SED_SAD1H); // P2
		// P3 - SL1 - Screen block start address - numbers of lines per display
		sed_data(SED_SL); // P3
		// P4:P5 = SAD2 L:H
		sed_data(SED_SAD2L); // P4
		sed_data(SED_SAD2H); // P5
		// P6 - SL2 - same as SL1
		sed_data(SED_SL); // P6
		// P7:P8 = SAD3 L:H
		sed_data(SED_SAD3L); // P7
		sed_data(SED_SAD3H); // P8
		// P9:P10 = SAD4 L:H
		sed_data(SED_SAD4L); // P9
		sed_data(SED_SAD4H); // P10
		sed_command(0x5D); // CSR FORM
		sed_data(5); // CRX <= FX - cursor width (8px - same as char width)
		//sed_data(0x87); // CRY = FY-1 - cursor height (8px - same as char height) ; CM=1 - block cursor
		sed_data(0x80|7); // CRY = FY-1 - cursor height (8px - same as char height) ; CM=0 - line cursor
		sed_command(0x4C); // CSRDIR - Cursor move in right dir.
	sed_command(0x5A); // HDOT SCR
		sed_data(0x00); // 0=no horizontal scroll of display 
	sed_command(0x5B); // OVLAY
		// MX0,MX1 = [0:1] 0,0=OR (0x01,0x02)
		// DM1,DM2 = [2:3] 0,0=Text mode for Layer 1 and 3 (Layer 1 Upper panel, Layer 1 lower panel) (0x04,0x08)
		// OV = [4] 0 - Mixed mode (text+graph), two layer (0x10)
		sed_data(0x01); 
	/*
	sed_command(0x58); // disp ON/OFF => disable screen
		// FC0,1 = [0:1] (0x01,0x02) - cursor flash rate
		// FP0,1 = [2:3] (0x04,0x08) - SAD1 ON/OFF + flashing
		// FP2,3 = [4:5] (0x10,0x20) - SAD2,4 ON/OFF + flashing
		// FP4,5 = [6:7] (0x40,0x80) - SAD3 ON/OFF + flashing
		sed_data(0x04|0x10|0x40); // SAD1, SAD2&4, SAD3 = ON
*/
	sed_command(0x59); // disp ON/OFF => DISP_ON
		// FC0,1 = [0:1] (0x01,0x02) - cursor flash rate
		// FP0,1 = [2:3] (0x04,0x08) - SAD1 ON/OFF + flashing
		// FP2,3 = [4:5] (0x10,0x20) - SAD2,4 ON/OFF + flashing
		// FP4,5 = [6:7] (0x40,0x80) - SAD3 ON/OFF + flashing
		sed_data(0x04|0x10|0x40); // SAD1, SAD2&4, SAD3 = ON
	
	// zero memory
	sed_command(SED_DRAW_CSRW);
		sed_data(0); sed_data(0);
	sed_command(SED_MEM_MWRITE);
	for (uint16_t t=0;t<0x8000;t++) sed_data(0);
	sed_mode = SED_MODE_TEXT;
	sed_disp = SED_DISP1;
}

void sed_load_CGRAM(void) {
	// **********************************************************************
	// **********************************************************************
	// **********************************************************************
	// load "pl" chars to in video ram after SAD4 (2nd text layer - lower panel)

		#define SED_SAG_START ((uint16_t)(0))
		#define SED_SAG_START2 ((uint16_t)(0x0400))
		// setup CG-RAM...
		sed_command(SED_DISPLAY_CGRAM_ADR);
			sed_data(SED_SAG_START & 0xff); // SAG Low
			sed_data((SED_SAG_START>>8) & 0xff); // SAG high

		sed_command(SED_DRAW_CSRW);
			sed_data(SED_SAG_START2 & 0xff); // Low address
			sed_data((SED_SAG_START2>>8) & 0xff); // high address
		sed_command(SED_MEM_MWRITE);
		for (uint8_t t=0;t<pl_text_font_SIZE;t++) sed_data(pgm_read_byte(&pl_text_font[t]));
}

void sed_initGraph(void) {
	PORT(SED_PORT_DATA) = 0xff;
	DDR(SED_PORT_DATA) = 0xff;
	DDR(SED_PORT_CTRL) |= (1<<SED_PIN_RST | 1<<SED_PIN_CS | 1<<SED_PIN_RW | 1<<SED_PIN_EN | 1<<SED_PIN_A0);
	PORT(SED_PORT_CTRL) |= (1<<SED_PIN_RST | 1<<SED_PIN_CS | 1<<SED_PIN_RW | 1<<SED_PIN_EN | 1<<SED_PIN_A0);
	// Reset :)
	delay1ms(20);
	//sed_cs_control = SED_CS_CTRL_AUTO;
	sed_set_cs();
	sed_set_rd();
	sed_set_wr();
	
	sed_clr_rst();
	delay1ms(5); // min. 200us
	sed_set_rst();
	delay1ms(10);
	// SYSTEM SET
	sed_command(0x40); // system set
		// P1:
		//  *[0] M0 (0x01) - 0=Internal CG ROM, 1=External
		//  *[1] M1 (0x02) - 0=CG RAM1 32char, 1=64char CG RAM + CG RAM2
		//  *[2] M2 (0x04) - 0=8px char height , 1=16px char height <- External CG ROM
		//  *[3] W/S (0x08) - 0=Single panel LCD , 1=Dual panel LCD
		//  *[4] 1 (0x10) - 1= Always 1...
		//  *[5] IV (0x20) - 0=Screen top-line correction , 1=No correction
		//  *[6] TL (0x40) - 0=LCD Mode , 1=TV Mode (Only SED1336 ?)
		//  *[7] DR (0x80) - 0=Normal , 1=Additional Shift clock cycles
		sed_data(0x08|0x10|0x20); // M2:M0=000, WS=1, IV=1, TL=0, DR=0
		// P2:
		//  *[2:0] FX (0x00...0x07) - Character field width + 1 (1...8)
		//  *[7] WF (0x80) - 0=16line AC Drive, 1=Two-frame AC Drive
		sed_data(7); // FX=7 (8px) or FX=5 (6px), WF=0 ::: FX >= DisplayWidth / CharsPerLine
		// P3:
		//  *[3:0] FY (0x00...0x0F) - Height in pixels of character + 1 (1...16)
		sed_data(7); // FY=7 (8px)
		// P4: 
		//  *[7:0] CR (0x00...0xEF - 0...239) - "Section 3.2.1.12" :::  CR=RND(FX / 8) * CharsPerLine
		sed_data(32); // CR=32=0x20 for FX=7 ;  
		// P5:
		//  *[7:0] TCR (0x00...0xFF - 1...256) - must be: >= CR+4
		sed_data(38); // P5: TCR=36
		// P6:
		//  *[7:0] LF (0x00...0xFF) - Height in lines of frame, height=LF+1
		sed_data(127); // LF=63+1=64
		// P7 & P8 - AP - horizontal address range = 256 = 0x0100 => [15:8-7:0] 0x01-0x00
		//  *[15:0] AP - horiontal address range of the virtual screen (same as CR??)
		#define SED_AP_GRAPH (uint16_t)32
		#define SED_APL_GRAPH (SED_AP_GRAPH&0xff)
		#define SED_APH_GRAPH (SED_AP_GRAPH>>8)
		sed_data(SED_APL_GRAPH); // P7 - AP Low
		sed_data(SED_APH_GRAPH); // P8 - AP High
	
	// Memory map:
	// Hint: Display 1 - upper panel; Display 2 - lower panel
	// TEXT: Chars per display: 32*8=256chars (bytes) per display - we have 2 displays...
	// GRAPH: ((256*64)/8) = 2048bytes - 0x0800
	// SAD1 :> dispaly 1, Layer 1 ( TEXT ) - 8rows, 32char = 256chars per panel
	// SAD3 :> display 2, Layer 1 ( TEXT )
	// SAD2 :> display 1, Layer 2 ( Graphic ) ; 64 rows, 256cols = 16384 / 8bits = 2048bytes per panel
	// SAD4 :> display 2, Layer 2 ( Graphic )
	sed_command(0x44); // Scroll
		// P1:P2 = SAD1 L:H
		sed_data(SED_SAD1L); // P1
		sed_data(SED_SAD1H); // P2
		// P3 - SL1 - Screen block start address - numbers of lines per display
		sed_data(SED_SL); // P3
		// P4:P5 = SAD2 L:H
		sed_data(SED_SAD2L); // P4
		sed_data(SED_SAD2H); // P5
		// P6 - SL2 - same as SL1
		sed_data(SED_SL); // P6
		// P7:P8 = SAD3 L:H
		sed_data(SED_SAD3L); // P7
		sed_data(SED_SAD3H); // P8
		// P9:P10 = SAD4 L:H
		sed_data(SED_SAD4L); // P9
		sed_data(SED_SAD4H); // P10		
	sed_command(0x5A); // HDOT SCR
		sed_data(0x00); // 0=no horizontal scroll of display 
	sed_command(0x5B); // OVLAY
		// MX0,MX1 = [0:1] 0,0=OR (0x00) [ L1 | L2 | L3 ]
		// MX0,MX1 = [0:1] 0,1=EX-OR (0x01) [ (L1 ^ L2) | (L3 ^ L4) ] // L2 and L4 equal?
		// MX0,MX1 = [0:1] 1,0=AND (0x02) [ (L1 & L2) | (L3 & L4) ]
		// MX0,MX1 = [0:1] 1,1=PriorityOR (0x03) [ L1 > L2(L4??) > L3)
		// DM1,DM2 = [2:3] 0,0=Text mode for Layer 1 and 3 (Layer 1 Upper panel, Layer 1 lower panel) (0x00)
		// DM1,DM2 = [2:3] 1,1=Graphic mode for Layer 1 and 3 (Layer 1 Upper panel, Layer 1 lower panel) (0x0C)
		// OV = [4] 0 - Mixed mode (text+graph), two layer (0x10)
		sed_data(0x01); 
	sed_command(0x58); // disp ON/OFF => disable screen
	
	// "zero" whole memory
	sed_command(SED_DRAW_CSRW);
		sed_data(0); sed_data(0);
	sed_command(SED_MEM_MWRITE);
	for (uint16_t t=0;t<0x8000;t++){ sed_data(0x00);}
	sed_command(0x5D); // CSR FORM
		sed_data(8); // CRX <= FX - cursor width (8px - same as char width)
		//sed_data(0x87); // CRY = FY-1 - cursor height (8px - same as char height) ; CM=1 - block cursor
		sed_data(0x80|8); // CRY = FY-1 - cursor height (8px - same as char height) ; CM=0 - line cursor
	sed_command(0x59); // disp ON/OFF => DISP_ON
		// FC0,1 = [0:1] (0x01,0x02) - cursor flash rate
		// FP0,1 = [2:3] (0x04,0x08) - SAD1 ON/OFF + flashing
		// FP2,3 = [4:5] (0x10,0x20) - SAD2,4 ON/OFF + flashing
		// FP4,5 = [6:7] (0x40,0x80) - SAD3 ON/OFF + flashing
		sed_data(0x04|0x10|0x40); // SAD1, SAD2&4, SAD3 = ON
	sed_command(0x4C); // CSRDIR - Cursor move in right dir.
	sed_mode = SED_MODE_GRAPH;
	sed_disp = SED_DISP1;
}


void sed_onoff(uint8_t on) {
	if (on == 1) {
		sed_command(0x59); // disp ON
		sed_data(0x04|0x10|0x40); // SAD1, SAD2&4, SAD3 = ON
	} else {
		sed_command(0x58); // disp OFF
		sed_data(0x00); // SAD1, SAD2&4, SAD3 = ON
	}
}


void sed_clear(uint8_t sec, uint8_t fill) {
	uint16_t t,t2;
	if (sec == SED_TEXT1) {
		t = SED_SAD1_SIZE;
		t2 = SED_SAD1;
	} else if (sec == SED_TEXT2) {
		t = SED_SAD3_SIZE;
		t2 = SED_SAD3;
	} else if (sec == SED_GRAPH1) {
		t = SED_SAD2_SIZE;
		if (sed_disp == SED_DISP2) {
			t2 = SED_SAD2_DISP2;
		} else if (sed_disp == SED_DISP3) {
			t2 = SED_SAD2_DISP3;
		} else {
			t2 = SED_SAD2_DISP1;
		}
	} else if (sec == SED_GRAPH2) {
		t = SED_SAD4_SIZE;
		if (sed_disp == SED_DISP2) {
			t2 = SED_SAD4_DISP2;
		} else if (sed_disp == SED_DISP3) {
			t2 = SED_SAD4_DISP3;
		} else {
			t2 = SED_SAD4_DISP1;
		}
	} else {
		return;
	}
	sed_command(SED_DRAW_CSRW);
		sed_data(t2 & 0xff); // Low address
		sed_data((t2>>8) & 0xff); // high address
	sed_command(SED_MEM_MWRITE);
	
	while (t--) {
	while(sed_readBusy()==1){}
		sed_data(fill);
	}
}

void sed_txt_char(char c) {
	sed_command(SED_MEM_MWRITE);
	sed_data(c);
}

void sed_txt_str(char* str) {
	char znak;
	sed_command(SED_MEM_MWRITE);
	while(0 != (znak = *(str++))){sed_data(znak);}
}

void sed_txt_str_P(prog_char* str) {
	char znak;
	sed_command(SED_MEM_MWRITE);
	while (0 != (znak = pgm_read_byte(str++))){sed_data(znak);}
}

void sed_txt_dec(int val) {
	char bufor[7];
	sed_txt_str(itoa(val, bufor, 10));
}

void sed_txt_setPos(uint8_t y, uint8_t x) {
	// 42 chars per line...
	uint16_t t;
	
	t = (y < 8) ? SED_SAD1 : SED_SAD3;
	y = (y < 8) ? y : (y-8);
	
	t += x;
	
	if (sed_mode == SED_MODE_TEXT) {
		t += y*42;
	} else {
		t += y*32;
	}
	sed_command(SED_DRAW_CSRW);
	sed_data(t);// Low address
	sed_data(t>>8); // high address
}

void sed_txt_hex_byte(uint8_t val) {
	if (((val >> 4) & 0x0f) > 0x09) {
		sed_txt_char('7'+((val >> 4) & 0x0f));
	} else {
		sed_txt_char('0'+((val >> 4) & 0x0f));
	}
	if ((val & 0x0f) > 0x09) {
		sed_txt_char('7'+(val & 0x0f));
	} else {
		sed_txt_char('0'+(val & 0x0f));
	}
}

void sed_setDisp(uint8_t dsp) {
	uint16_t sad[2];
	
	if (dsp == SED_DISP2) {
		sad[0] = SED_SAD2_DISP2;
		sad[1] = SED_SAD4_DISP2;
		sed_disp = SED_DISP2;
	} else if (dsp == SED_DISP3) {
		sad[0] = SED_SAD2_DISP3;
		sad[1] = SED_SAD4_DISP3;
		sed_disp = SED_DISP3;
	} else {
		sad[0] = SED_SAD2_DISP1;
		sad[1] = SED_SAD4_DISP1;
		sed_disp = SED_DISP1;
	}
	
	// Memory map:
	// Hint: Display 1 - upper panel; Display 2 - lower panel
	// TEXT: Chars per display: 32*8=256chars (bytes) per display - we have 2 displays...
	// GRAPH: ((256*64)/8) = 2048bytes - 0x0800
	// SAD1 :> dispaly 1, Layer 1 ( TEXT ) - 8rows, 32char = 256chars per panel
	// SAD3 :> display 2, Layer 1 ( TEXT )
	// SAD2 :> display 1, Layer 2 ( Graphic ) ; 64 rows, 256cols = 16384 / 8bits = 2048bytes per panel
	// SAD4 :> display 2, Layer 2 ( Graphic )
	sed_command(0x44); // Scroll
		// P1:P2 = SAD1 L:H
	sed_data(SED_SAD1L); // P1
	sed_data(SED_SAD1H); // P2
		// P3 - SL1 - Screen block start address - numbers of lines per display
	sed_data(SED_SL); // P3
		// P4:P5 = SAD2 L:H
	sed_data(sad[0]); // P4
	sed_data(sad[0]>>8); // P5
		// P6 - SL2 - same as SL1
	sed_data(SED_SL); // P6
		// P7:P8 = SAD3 L:H
	sed_data(SED_SAD3L); // P7
	sed_data(SED_SAD3H); // P8
		// P9:P10 = SAD4 L:H
	sed_data(sad[1]); // P9
	sed_data(sad[1]>>8); // P10
}

void sed_cursor(uint16_t addr) {

	sed_command(SED_DRAW_CSRW);
	sed_data(addr & 0xff); // Low address
	sed_data((addr>>8) & 0xff); // high address
	sed_data((addr>>8) & 0xff); // high address
}

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

#if SED_GRAPHIC_FUNCTIONS_ENABLED == 1

void sed_init(uint8_t mode) {
	if (mode == SED_MODE_TEXT) {
		sed_initText();
		sed_mode = SED_MODE_TEXT;
	} else {
		sed_initGraph();
		sed_mode = SED_MODE_GRAPH;
	}
}

uint16_t GetSAD24(uint8_t y) {
	if (y > 63) {
		if (sed_disp == SED_DISP2) {
			return SED_SAD4_DISP2;
		} else if (sed_disp == SED_DISP3) {
			return SED_SAD4_DISP3;
		} else {
			return SED_SAD4_DISP1;
		}
	} else {
		if (sed_disp == SED_DISP2) {
			return SED_SAD2_DISP2;
		} else if (sed_disp == SED_DISP3) {
			return SED_SAD2_DISP3;
		} else {
			return SED_SAD2_DISP1;
		}
	}
}


void sed_setPixel(uint16_t x, uint16_t y, uint8_t mode) {
	uint16_t t;
	uint8_t tmp,xp;
	// position :)
	t = GetSAD24(y);
	
	if (y > 63) y = y-64;
	
	if (y>127) y=0;
	
	// based on sed-mode calculate pixel position...
	if (sed_mode == SED_MODE_TEXT) {
		t += (y*42)+(x/6);
		xp=x%6;
	} else {
		t += (y*32)+(x/8);
		xp=x%8;
	}	
	
	
	sed_command(SED_DRAW_CSRW);
	
	sed_data(t);
	
	sed_data(t>>8);
	
	tmp=sed_read_memory();
	if (mode == SED_PX_ON) {
		tmp |= 0x80>>xp;
	} else if (mode == SED_PX_OFF) {
		tmp &= ~(0x80>>xp);
	} else if (mode == SED_PX_XOR) {
		if (tmp & (0x80>>xp)) {
			tmp &= ~(0x80>>xp);
		} else {
			tmp |= 0x80>>xp;
		}
	}
	
	sed_command(SED_DRAW_CSRW);
	
	sed_data(t);
	
	sed_data(t>>8);
	
	sed_command(SED_MEM_MWRITE);
	
	sed_data(tmp);
}

#ifdef SED_FUNCT_LINE
void sed_lineH(uint16_t x, uint8_t y, uint16_t w, uint8_t px_mode) {
	//if ((x1 >= SED_WIDTH) || (x2 >= SED_WIDTH) || (y1 >= SED_HEIGHT) || (y2 >= SED_HEIGHT) || (x1 > x2) || (y1 > y2))  return;
	if (x >= SED_WIDTH) x = SED_WIDTH-1;
	if (y >= SED_HEIGHT) y = SED_HEIGHT-1;
	w = w+x;
	if (w>= SED_WIDTH) w = SED_WIDTH-1;
	
	for (;x<=w;x++) sed_setPixel(x,y,px_mode);
}

void sed_lineV(uint16_t x, uint8_t y, uint8_t h, uint8_t px_mode) {
	//if ((x1 >= SED_WIDTH) || (x2 >= SED_WIDTH) || (y1 >= SED_HEIGHT) || (y2 >= SED_HEIGHT) || (x1 > x2) || (y1 > y2))  return;
	if (x >= SED_WIDTH) x = SED_WIDTH-1;
	if (y >= SED_HEIGHT) y = SED_HEIGHT-1;
	h = h+y;
	if (h>= SED_HEIGHT) h = SED_HEIGHT-1;
	
	for (;y<=h;y++) sed_setPixel(x,y,px_mode);
}

void sed_line(uint16_t x1, uint8_t y1, uint16_t x2, uint8_t y2, uint8_t px_mode) {
	int16_t dx,dy,sx,sy,f;
	uint16_t i;
	
	if (x1 > x2) {
		XCHG(x1,x2,uint8_t);
		XCHG(y1,y2,uint8_t);
	}
	
	if (y1 > y2) {
		XCHG(x1,x2,uint8_t);
		XCHG(y1,y2,uint8_t);
	}
	
	if (x1 == x2) {
		sed_lineV(x1,y1,(y2-y1),px_mode);
		return;
	}
	
	if (y1 == y2) {
		sed_lineH(x1,x1,(x2-x1),px_mode);
		return;
	}
	
	dx = x2 - x1;
	dy = y2 - y1;
	
	if (dx < 0) {
		dx = -dx;
		sx = -1;
	} else {
		sx = 1;
	}
	
	if (dy < 0) {
		dy = -dy;
		sy = -1;
	} else {
		sy = 1;
	}

	dx <<= 1; // Shift Dx , Left , 1  '-2
	dy <<= 1; // Shift Dy , Left , 1  '-2
	
	sed_setPixel(x1,y1,px_mode); // Call Lcdpixel(x1 , Y1 , Pixelmode)

	if (dx > dy) {
		i = dx;
		i >>= 1;
		f = dy-i;
		while (x1!=x2) {
			if (f >= 0) {
				y1 += sy; //Y1 = Y1 + Stepy
				f -= dx; //Fraction = Fraction - Dx
			}
         x1 += sx;
			f += dy;
			sed_setPixel(x1,y1,px_mode);
		}
	} else {
      i = dy;
		i >>= 1;
		f = dx-i;
		while (y1!=y2) {
			if (f >= 0) {
				x1 += sx;
				f -= dy; //Fraction = Fraction - Dy
			}
			y1 += sy;
			f += dx;
			sed_setPixel(x1,y1,px_mode);
		}
	}
}
#endif

#ifdef SED_FUNCT_RECT
void sed_rect(uint16_t x1, uint8_t y1, uint16_t x2, uint8_t y2, uint8_t px_mode) {
	uint16_t w,h;
	if (x1 >= SED_WIDTH) x1 = SED_WIDTH-1;
	if (y1 >= SED_HEIGHT) y1 = SED_HEIGHT-1;
	if (x2 >= SED_WIDTH) x2 = SED_WIDTH-1;
	if (y2 >= SED_HEIGHT) y2 = SED_HEIGHT-1;
	if (x1 > x2) { w = x1; x1 = x2; x2 = w; }
	if (y1 > y2) { h = y1; y1 = y2; y2 = h; }
	w = x2-x1;
	h = y2-y1;
	if (w>= SED_WIDTH) w = SED_WIDTH-1;
	if (h>= SED_HEIGHT) h = SED_HEIGHT-1;
	
	sed_lineH(x1,y1,w,px_mode);
	sed_lineH(x1,y2,w,px_mode);
	sed_lineV(x1,y1+1,h-2,px_mode);
	sed_lineV(x2,y1+1,h-2,px_mode);

}
#endif

#ifdef SED_FUNCT_RECT_FILL
void sed_rectFill(uint16_t x1, uint8_t y1, uint16_t x2, uint8_t y2, uint8_t px_mode) {
	uint8_t y;
	if (x1 >= SED_WIDTH) x1 = SED_WIDTH-1;
	if (y1 >= SED_HEIGHT) y1 = SED_HEIGHT-1;
	if (x2 >= SED_WIDTH) x2 = SED_WIDTH-1;
	if (y2 >= SED_HEIGHT) y2 = SED_HEIGHT-1;
	if (x1 > x2) { y = x1; x1 = x2; x2 = y; }
	if (y1 > y2) { y = y1; y1 = y2; y2 = y; }
	for (;x1<=x2;x1++) {
		for (y=y1;y<=y2;y++) {
			sed_setPixel(x1,y,px_mode);
		}
	}
}
#endif

#ifdef SED_FUNCTS_STRINGS
uint8_t sed_char(uint16_t x, uint8_t y, char znak, uint8_t chr_mode) {
	if ((znak > (GPH_CHAR_COUNT+GPH_CHAR_START)) || (znak < GPH_CHAR_START)) znak = GPH_CHAR_START;
	// calculate char location in array
	uint16_t t=(znak-GPH_CHAR_START)*GPH_CHAR_WIDTH;
	uint8_t b;
	for (uint8_t i=x;i<(GPH_CHAR_WIDTH+x);i++) {
		// draw x bytes of char - char byte data orientation vertically
		// get column byte of char
		//b = pgm_read_byte(&g_font5x8[t++]);
		b = pgm_read_byte(&GPH_FONT_NAME[t++]);
		// vertical draw byte...
		for (uint8_t j=y;j<(y+GPH_CHAR_HEIGHT);j++) {
			#if (GPH_FONT_COLUMN_UP_DOWN == 1)
				if (b & 0x80) {
			#else
				if (b & 0x01) {
			#endif
				if ((chr_mode == SED_TEXT_PIX_ON) || (chr_mode == SED_TEXT_PIX_ON_BG_OFF)) {
					sed_setPixel(i,j,SED_PX_ON);
				} else if ((chr_mode == SED_TEXT_PIX_OFF) || (chr_mode == SED_TEXT_PIX_OFF_BG_ON)) {
					sed_setPixel(i,j,SED_PX_OFF);
				} else if (chr_mode == SED_TEXT_PIX_XOR) {
					sed_setPixel(i,j,SED_PX_XOR);
				}
			} else { // draw background (if needed...)??
				if (chr_mode == SED_TEXT_PIX_ON_BG_OFF) { // black char on white bg
					sed_setPixel(i,j,SED_PX_OFF);
				} else if (chr_mode == SED_TEXT_PIX_OFF_BG_ON) { // white char on black bg
					sed_setPixel(i,j,SED_PX_ON);
				//} else if (chr_mode == TEXT_PIX_XOR) { // xor
				//	sed_setPixel(i,j,PX_XOR);
				}
			}
			#if (GPH_FONT_COLUMN_UP_DOWN == 1)
				b <<= 1;
			#else
				b >>= 1;
			#endif
			
		}
	}
	return GPH_CHAR_WIDTH;
}

uint8_t sed_str(uint8_t x, uint8_t y, char* str, uint8_t txt_mode) {
	while(*str != 0) {
		sed_char(x, y, *str++, txt_mode);
		x += GPH_CHAR_WIDTH;
	}
	return x;
}	

uint8_t sed_str_P(uint8_t x, uint8_t y, char* str, uint8_t txt_mode) {
	char znak;
	while (0 != (znak = pgm_read_byte(str++))) {
		sed_char(x, y, znak, txt_mode);
		x += GPH_CHAR_WIDTH;
	}
	return x;
}		

uint8_t sed_dec(uint8_t x, uint8_t y, int val, uint8_t txt_mode) {
	char bufor[5];
	return sed_str(x,y,itoa(val, bufor, 10),txt_mode);
}	
#endif

#ifdef SED_FUNCT_HEX_BYTE
uint8_t sed_hex_byte(uint8_t x, uint8_t y, uint8_t val, uint8_t txt_mode) {
	if (((val >> 4) & 0x0f) > 0x09) {
		sed_char(x,y,'7'+((val >> 4) & 0x0f), txt_mode);
	} else {
		sed_char(x,y,'0'+((val >> 4) & 0x0f), txt_mode);
	}
	x += GPH_CHAR_WIDTH;
	if ((val & 0x0f) > 0x09) {
		sed_char(x,y,'7'+(val & 0x0f), txt_mode);
	} else {
		sed_char(x,y,'0'+(val & 0x0f), txt_mode);
	}
	return x+=GPH_CHAR_WIDTH;
}	
#endif

#ifdef SED_FUNCT_LOAD
void sed_load(prog_uint8_t* pData, uint16_t x, uint8_t y, uint16_t w, uint8_t h, uint8_t px_mode) {
	uint16_t b,y2,x2,t=0;
	//h--;
	w+= x;// = (w-1) + x;
	h+= y;// = (h-1) + y;
	
	if ((w > SED_WIDTH) || (h > SED_HEIGHT)) return;
	
	for (y2=y;y2<h;y2++) {
		x2=x;
		while (x2<w) {
			b = pgm_read_byte(pData++);
			for (t=0;t<8;t++) {
				if (b & 0x80) {
					sed_setPixel((x2+t),y2,px_mode);
				}
				b <<= 1;
			}
			x2+=8;
		}
	}
}
#endif


#endif

    działa ale pierwsze 8pixeli każdej lini migocze :(
  • #97
    djkomprez
    Level 21  
    gbr3, odpisał byś czasem na gg :P
  • phoenixcontact
  • #98
    djkomprez
    Level 21  
    OK , blednę kolo miałem :)

    Okazało sie ze coś było z liniami od pamięci do SED-a ...
    Gdzieś coś nie łączyło lub było zwarte ... poprawiłem działa :)
    Juz gada z AT16 ;)

    Buahahah ... i sie spolił !!! nie wiem czemu .. poszedł kontrast
    i na lcd już nic nie ma :) trudno ... trza będzie kupić nowy .. albo i ze 2 :D
  • #99
    saper_2
    Level 18  
    gbr3, tra było wkleić kawałek/jako załącznik ,a nie mi tu kółko od myszy każesz wyrabiać tyle przewijając :) ,o i widze ze troche opoźnień wywaliłewś :) ;

    djkomprez wrote:

    Buahahah ... i sie spolił !!! nie wiem czemu .. poszedł kontrast
    i na lcd już nic nie ma :) trudno ... trza będzie kupić nowy .. albo i ze 2 :D

    Hehehe, robimy zakłady :) "Jak szybko djkomprez spali kolejny LCD" :lol!:
  • #100
    wdogli
    Level 18  
    Hej Saper bawiłeś się kiedyś kartami pamięci Compact Flasch podpiętymi do AVR??
  • #101
    gbr3
    Level 15  
    :arrow: wdogli czy mógłbyś zdradzić sekret "nie migotania" lcdka bo mnie to już wykańcza jeszcze tylko nie próbowałem z linią lp jako przerwanie ale jakoś mi sie nie widzi ciągnięcie jeszcze jednego kabla.

    :arrow: saper_2 a chociaż zmniejszyło Ci sie to migotanie czy bez różnicy?
    Ps: wysłałem komprezowi płytke z dobrymi scalakami ale dużo to nie pomogło seda też uwalił...
  • #102
    wdogli
    Level 18  
    Witam.

    Jedyne czym mogę ci pomóc to podanie parametrów konfiguracyjnych oto one :
    Code: text Expand Select all Copy to clipboard
    
void lcd_wyswietlaj(void)
{
lcdg_write_cmd(0x44);   //C   SCROLL

lcdg_write_data(0x00);  //P1
lcdg_write_data(0x00);  //P2
lcdg_write_data(0x3F);  //P3

lcdg_write_data(0x00);  //P4
lcdg_write_data(0x02);  //P5
lcdg_write_data(0x3F);  //P6

lcdg_write_data(0x00);  //P7
lcdg_write_data(0x01);  //P8   

lcdg_write_data(0x00);  //P9
lcdg_write_data(0x0A);  //P10 

lcdg_write_cmd(0x5A);   //C    HDOT SCR
lcdg_write_data(0x00);  //P1

lcdg_write_cmd(0x5B);   //C    OVLAY
lcdg_write_data(0x01);  //P1=>   0 0 0 OV DM2 DM1 MX1 MX0   określa tyb wyświetlania
lcdg_write_cmd(0x58);   //C    DISP ON/OFF
lcdg_write_data(0x57);  //P1=>   FP5, FP4, FP3, FP2, FP1, FP0, FC1, FC0  włącza i wyłącza wyświetlanie

lcdg_write_cmd(0x46);   //C    CSRW  ustawienie kursora w rządanym punkcie 
lcdg_write_data(0x00);  //P1    współrzędna CSRL
lcdg_write_data(0x00);  //P2    współrzędna CSRH

lcdg_write_cmd(0x5D);   //C    CSR FROM  --
lcdg_write_data(0x07);  //P1  szerokość kursora w pikselach
lcdg_write_data(0x08);  //P2  wysokośc kursora w liniach

lcdg_write_cmd(0x59);   //C    DISP ON/OFF
lcdg_write_data(0x57);  //P1=>   FP5, FP4, FP3, FP2, FP1, FP0, FC1, FC0  włącza i wyłącza wyświetlanie


    Mi nic nie miga.

    Poza ty jeśli chcesz podeślij mi swoje schematy. Przeglądnę je i postaram się pomóc. Acha ja taktuje seda 8MHz.
    Pozdrawiam
  • #103
    rpal
    Level 27  
    Też dołączam do grona zainteresowanych. Rozumiem że pamięci SRAM I EPROM pochodzą z płyty POS-a ? Druga sprawa jaki to Panowie EPROM skoro pamięć nie ma możliwości skasowania UV, na mój gust to zwykły ROM fabrycznie zapisany. No chyba że lipko do kasowania jest od spodu.
  • #104
    saper_2
    Level 18  
    rpal - to jest precyzyjniej EPROM :), poza tym nie jest on potrzebny, wystarcza sam ram+sed - zobacz na mój projekt ma tylko sed'a i ram i działa :).
    Jak chcesz na upartego dawać jeszcze pamięć extra to wsadź jaką kolwiek inną kompatybilną :D nie większą jak 32kb (w sumie to można i większą :D ale musiałbyś ją przełącząc dodatkowymi nogami procka jak byś chciał większy zakres jej wykożystać - czyli adresować powyżej 64k ... )

    Chyba żem namieszał co nie :D
  • #105
    rpal
    Level 27  
    Mniejsza o ten eprom. Możesz kolego powiedzieć po co ci ten MB15167 ? I takie pytanko czy kol. Wdodli opublikował jakieś konkrety w kwestii PCB i zastosowanego schematu ? ALbo niedokładnie czytałęm posty albo jestem ślepy bo nie widzę.
  • #106
    saper_2
    Level 18  
    MBI po co... do podświetlania LED :) ,dostępny w Maritex'ie .... A wdogli chyba nie wrzucał nigdzie rysunków płytki...
  • #107
    rpal
    Level 27  
    Przyznam się że nie czytałem noty od tego MBI. Rozumiem że wpisanie po SPI jakiejś tam wartości powoduje zmniejszenie jasności diod LED? Nie prościej było zrobić to w przerwaniu Timera i regulować jasność wypełnieniem przebiegu ? Potrzebny jest tylko jeden pin procesora i nie trzeba fatygować procesora obsługą po SPI.
    Natomiast w kwestii EPROM. Ile tak na oko zajmują dane tablicy znaków. Z tego co widzę to jest na nie 32 KB. Czy to wyczerpuje ilość pamięci tylko na jeden zestaw znaków czy na więcej. Pamięć o takiej pojemności jest zdaje się w oryginalnej płycie.
    Widzę że trwały tu rozważania tema obsługi tego wyświetlacza za pomocą ATMegi. Zrobiłem pobieżne wyliczenia (mam nadzieję że dokładne) i wyszło mi że przy prędkości zegara taktującego wyświetlacz (szerokość połówki przebiegu 100 ns czyli okres 200 ns - częstotliwość zatem 5 MHz) nie ma za wiele czasu aby cokolwiek tam zapisywać w rejestry wyświetlacza. Najszybszy ATMega ma zegar 20 MHz i nawet jeśli na jedną operację procesora potrzebny byłby 1 cykl zegarowy (a przecież zwykle potrzeba 2) to nie ma szansy na jakąkolwiek obsługę. Udało się to komuś na ATmega, chyba nie ?
  • #108
    saper_2
    Level 18  
    hmmm... z bezpośrednim sterowaniem były tu pozytywne wyniki przejżyj posty... A co do MBI to nic innego jak 8bit driver prądowy - do 8led ON/OFF ,proąd reguluje się przez tam któryś rezytor ja mam chyba 810R...
  • #109
    rpal
    Level 27  
    Próby były istotnie ale potwierdza to moje przypuszczenia że mały AVR do tego sie nie nadaje.
  • #110
    saper_2
    Level 18  
    Zrobiłem mały update swojego sterownika... Nowa wersja dostała możliwość obsługi fontu wyższego niż 8px i mała poprawka funkcji sed_load tak ,że funkcja nadmalowuje stare pixele ,a nie tylko maluje nowe... (tak trochę zkręcone to wyjaśnienie :D ) link do chomika także na stronie: http://del-el.jcom.pl/?module=2&smod=9&mode=2&id=2
  • #111
    ghost666
    Translator, editor  
    Mam wyświetlacz DMF6104B-FW, czy dysponuje ktoś może schematem jak go podłączyć? Pytam, gdyż z Datasheeta wynikają niejasne informacje na temat podłączenia Vee i napięcia jakie trzeba na nie podać (względem masy). Ponadto, czy aby nie trzeba sterować tym napięciem? Karta katalogowa tego LCD mówi że w procedurze włączania trzeba najpierw podać tam Vcc, a potem Vee i już zgłupiałem.
    LCD chcę podłączyć do szybkiego uC (ADSP845 albo PIC18), a nie do SEDa, więc te schematy które tutaj są, są dla mnie nie istotne.
  • #112
    wdogli
    Level 18  
    Hej.

    Z tymi napięciami to sprawa wygląda w ten sposób że sterownik zasilasz napięciem VCC = +5V natomiast kontrast wyświetlacza zasilasz napięciem VEE = -12V.
    A więc napięcie kontrastu nie jest podpięte bezpośrednio do wyświetlacza tylko poprzez oporek regulowany 10kOm i do masy.
    dokładny schemat leży tutaj Link

    Natomiast jeśli chodzi o procedurę włączania zasilania we wszystkich jak mi się zdaje wyświetlaczach LCD jest ona taka jak piszesz czyli najpierw należy włączyć zasilane sterownika +5V następnie przeprowadzasz procedurę inicjalizacji sterownika a dopiero potem włączasz ujemne napięcie na matrycę. Jeśli nie zrobisz tego w tej kolejności może zdarzyć się że będziesz zasilał napięciem stałym struktury ciekłego kryształu co powoduje elektrochemiczną degradację matrycy LC. Nie napisałem tego z pamięci przepisałem z dokumentu który możesz znaleźć tutaj :)))
    Link
    Pozdrawiam :)
  • #113
    ghost666
    Translator, editor  
    wdogli - Dzięki za informacje.

    Czy lepiej zrobić sterownik na SED1330 (który jednak mam), czy od razu podłączyć tą matryce do uć? Które rozwiązanie będzie efektywniejsze i łatwiejsze do zrealizowania?

    Czy mógłby tutaj ktoś zamieścić dokumentacje sterownika opartego o SED1330 do tego LCD? Widziałem że ktoś już to zrobił, a nie widzę sensu w robieniu tego, skoro już zostało zrobione ;). Z góry dziękuje za udostępnienie projektu (jak by był w eaglu, to już w ogóle cudownie).
  • #114
    wdogli
    Level 18  
    Hej.
    Mi się udało zrobić taki sterownik oparty na sed1330 i używam go na co dzień. Jednak niestety dla ciebie nie jest on w całości w eaglu. Cały sterownik składa się z kilku osobnych elementów ( płytka z sedem, płytka z pamięciom RAM, płytka kontrastu i płytka z bramką odwracającą sygnały do wyświetlacza ) które do kupy połączyłem dopiero na płycie stykowej. Jeśli chcesz mogę zrobić kilka szkiców i przesłać ci je jednak nie będzie to na dziś.
    Pozdrawiam
  • #115
    ghost666
    Translator, editor  
    Wystarczyłby mi schemat, nie koniecznie nawet w Eaglu - format dowolny, najwyżej manualnie skonwertuje to do Eagla ;). Szczególnie że i tak chciałbym wrzucić to na jedną płytkę, może nawet z uC od razu. Zatem będę wdzięczny za jakąkolwiek dokumentacje, gdyż to co dostępne jest w sieci jest bardzo skąpe, a w dodatku niejasne (przynajmniej karta katalogowa SEDa nie jest najlepiej napisanym datasheetem, jaki czytam).
  • #116
    saper_2
    Level 18  
    DS faktycznie nie jest zbyt dobrze napisany... Przejrzyj wątek wstecz tam zamieszczałem swoje schematy płytek co prawda mam osobno sed i ram ale można je połączyć tak że płytka nie będzie wyższa od goldpinów. Na jednej płytce wszystko (sed+ram) miałem w v1.
  • #117
    ghost666
    Translator, editor  
    saper_2, znalazłem Twoje schematy i projekty i w/g nich projektuje swój sterownik. Jak tylko skończę rysować schemat w Eaglu to go wstawię - do ew. korekt ;).
  • #119
    rpal
    Level 27  
    Pytanie do kolegi sapera. Tak się składa że i ja się za to wziąłem. Zrobiłem odpowiednią płytkę no i niestety nie działa, chodzi o to że wysyłane polecenia do sterownika nie odnoszą żadnego efektu. Przy załaczaniu napięcia ekran LCD na chwile potrafi zbieleć, kilka linii zapala się podczas resetu procka sterującego (ATMEGA16) ale generalnie lipa. Takie pytanie, kolega wstawił bramkę w sterowanie pamięcią RAM z linii VR/W. Ja postąpiłem zgodnie z notą czyli linia OE na stałe do masy bo i tak w przypadku poziomu LOW na linii WE pamięcię będzie ustawiona do zapisu danych a nie do odczytu. To moim zdaniem nie jest błąd ale chciałbym wiedzieć po co wsadziłeś tą bramkę które neguje sygnał. Drugie pytanie po co podłączasz sygnały sterujące pod wyprowadzenia LCD które oznaczone są NC, to przecież wisi tylko w powietrzu?
    Następne pytanie skąd takie egzotyczne sterowanie linią CS - pamięci ram przecież do tego jest linia VCE a tutaj jest użyta po prostu linia adresu A15 ?
    Kolejne pytanie jaką masz częstotliwość kwarca, schemat powiada że 6 MHz, fotografie że 4 MHz. Ostatnie pytanie to może masz jakiś sposób na szybkie zdiagnozowanie gdzi jest błąd w sprzęcie czy w sofcie. Wprawdzie mam oscyloskop ale nie ma on aż tyle kenałów aby każdą linię podłaczyć i oglądać. SED pracuje widzę to po generowaniu przebiegów ale niestety coś jest nie teges bo póki co nie chce to chodzić.

    Przyznam nie używam Waszych procedur, po muszę powiedzieć że pisaliście to po bałaganiarsku i analiza komentarzy które mają być jakby nie było pomocą dla innych wykazuje że nie odpowiadają one prawdzie, głownie w przypadku opisów linii sterujących np. CS!
    Więc pozwoliłem sobie sam napisać, także z tego powodu że używam CodeVision i staram się wstawiać wstawki w assemblerze. Jednak analiza procedur daje jakieś pojęcie. Będę wdzięczny za ew. rady. Skłaniam się jednak do zastosowania się do schemau z noty, pytanie tylko po co producentowi kasy było zastosowanie tak dużego EPROMA. Chyba tylko po to aby przełaczać się różnych fontach bo nota opisuje że starczy 4096x8 . PZDR
  • #120
    saper_2
    Level 18  
    Połączenia mam identycznie jak na płycie było. Coś mi świta iż podłączenie na stałe OE ustawia na stałe linie danych pamięci w tryb OUT albo IN nie pamiętam (takie coś to ktoś chyba próbował już :) )... w każdym razie od tego zależy kierunek działania bus'a... Bramkę taką miałem (one-gate) więc dałem bo tak też było oryginalnie - btw. na niej jest przebieg jak patrzałem oscyloskopem...
    Taki duży eporm pozwala na umieszczenie grafik, nie tylko fontów :). Ja nie używam epormu :) bo to za dużo kłopotu z płytką było by :D (na jednostronnej to bym zworek miał więcej niż ścieżek...).
    ....z kwarcem debatowałem z chyba gbr3 lub komprez'em albo może i kimś innym jeszcze i w sumie wyszło mi, że:
    szybszy kwarc wymaga zmiany któregoś parametru (T/CR?) ... to 4 czy 6Mhz to bez różnicy...

    Btw. Polecam samemu napisać sterowniki do podzespołów, przynajmniej traci się mniej czasu na wgryzanie się w czyjś kod niż napisanie od nowa samemu. Mój kod to taki niezbyt ładny :] bo w sumie za dużo nie pracowałem nad nim i optymalizacją...

    Hmm jak coś pominąłem to nie bij :)
Reply | New topic