Elektroda.pl
Elektroda.pl
X

Search our partners

Find the latest content on electronic components. Datasheets.com
Elektroda.pl
Farnell IoTFarnell IoT
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 12 Oct 2008 16:40 48861 275
  • #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.
  • Farnell IoTFarnell IoT
  • #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:


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

    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
  • Farnell IoTFarnell IoT
  • #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:

    #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
  • #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 17  
    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:

    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 17  
    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 17  
    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 17  
    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 17  
    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 17  
    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 17  
    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 :)
pcbway logo