-
        

Ergebnis 1 bis 2 von 2

Thema: SDA5708-24 display mit atmega8

  1. #1
    Erfahrener Benutzer Roboter Genie Avatar von robocat
    Registriert seit
    18.07.2006
    Beiträge
    935

    SDA5708-24 display mit atmega8

    Anzeige

    SMARTPHONES & TABLETS-bis zu 77% RABATT-Kostenlose Lieferung-Aktuell | Cool | Unentbehrlich
    hallo ihr lieben,
    eigentlich steht schon alles wissenswerte über dieses display auf der seite vom verehrten Grautier http://www.grautier.com/grautier/ind...A-5708-24.html und auf http://www.sbprojects.com/knowledge/...ts/sda5708.htm, was fehlt, ist höchstens noch ein bisschen c code dazu. vielleicht hilft es ja mal jemandem.

    für die pinbelegung siehe die genannten seiten, die 4 leitungen DATA, LOAD, SDCLK und RESET kommen an 4 pins des atmega. ich habe in meinen codebeispielen PC2-PC5 (also port c) verwendet, ist aber nicht schwer, diese leitungen auf andere pins/ports zu verteilen.

    der folgende code initialisiert dann das display und schaltet alle leds des ersten segments ein:

    Code:
    #include<avr/io.h>
    
    #define PORT PORTC
    #define DDR DDRC
    
    #define RESET PC2
    #define SDCLK PC3
    #define DATA PC4
    #define LOAD PC5
    
    void delay(void)
    {
      for(int i=0;i<100;i++)
      {
        asm("NOP");
      }
    }
    
    void transmitBit(unsigned char bit)
    {
      // das aktuelle bit an DATA anlegen
      if(bit==1)PORT|=(1<<DATA);
      else PORT&=~(1<<DATA);
    
      // SDCLK kurz auf high, bissl warten
      PORT|=(1<<SDCLK);
      delay();
    
      // dann wieder low
      PORT&=~(1<<SDCLK);
      delay();
    
    }
    
    void transmitByte(unsigned char byte)
    {
      // load auf low
      PORT&=~(1<<LOAD);
    
      // nun die 8 bit des bytes übertragen
      for (int x=0; x<=7;x++) 
      { 
        unsigned char bit=(byte>>x)&1; 
    	transmitBit(bit);
      }
    
      // load wieder auf high
      PORT|=(1<<LOAD);
    }
    
    int main(void) 
    {
      // ausgänge konfigurieren
      DDR=(1<<RESET)|(1<<SDCLK)|(1<<DATA)|(1<<LOAD);
    
      // reset leitung auf high (kein aktiver reset mehr)
      PORT|=(1<<RESET);
    
      // kurz warten, wahrscheinlich nicht mal nötig
      delay();
    
      // initialisierung
      transmitByte(0b11000000);
      // addressregister = 1stes segment
      transmitByte(0b10100000);
      // nun die daten, die 5x7 leds sind damit alle aktiv
      transmitByte(0b00011111);
      transmitByte(0b00011111);
      transmitByte(0b00011111);
      transmitByte(0b00011111);
      transmitByte(0b00011111);
      transmitByte(0b00011111);  
      transmitByte(0b00011111);
      
      while(1);
      
      return 0;
    }
    nun möchte man gerne text auf dem display ausgeben. um nicht selber einen font basteln zu müssen, habe ich den von http://www.microsyl.com/nokialcd/nokialcd.html verwendet. allerdings sind da die daten spaltenweise im array, wir bräuchten sie für das SDA5708 aber zeilenweise. mit ein bisschen bitschubserei ist das aber kein problem:

    Code:
    #include<avr/io.h>
    
    #define PORT PORTC
    #define DDR DDRC
    
    #define RESET PC2
    #define SDCLK PC3
    #define DATA PC4
    #define LOAD PC5
    
    static const unsigned char FontLookup [][5] =
    {
        { 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp
        { 0x00, 0x00, 0x2f, 0x00, 0x00 },   // !
        { 0x00, 0x07, 0x00, 0x07, 0x00 },   // "
        { 0x14, 0x7f, 0x14, 0x7f, 0x14 },   // #
        { 0x24, 0x2a, 0x7f, 0x2a, 0x12 },   // $
        { 0xc4, 0xc8, 0x10, 0x26, 0x46 },   // %
        { 0x36, 0x49, 0x55, 0x22, 0x50 },   // &
        { 0x00, 0x05, 0x03, 0x00, 0x00 },   // '
        { 0x00, 0x1c, 0x22, 0x41, 0x00 },   // (
        { 0x00, 0x41, 0x22, 0x1c, 0x00 },   // )
        { 0x14, 0x08, 0x3E, 0x08, 0x14 },   // *
        { 0x08, 0x08, 0x3E, 0x08, 0x08 },   // +
        { 0x00, 0x00, 0x50, 0x30, 0x00 },   // ,
        { 0x10, 0x10, 0x10, 0x10, 0x10 },   // -
        { 0x00, 0x60, 0x60, 0x00, 0x00 },   // .
        { 0x20, 0x10, 0x08, 0x04, 0x02 },   // /
        { 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0
        { 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1
        { 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2
        { 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3
        { 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4
        { 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5
        { 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6
        { 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7
        { 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8
        { 0x06, 0x49, 0x49, 0x29, 0x1E },   // 9
        { 0x00, 0x36, 0x36, 0x00, 0x00 },   // :
        { 0x00, 0x56, 0x36, 0x00, 0x00 },   // ;
        { 0x08, 0x14, 0x22, 0x41, 0x00 },   // <
        { 0x14, 0x14, 0x14, 0x14, 0x14 },   // =
        { 0x00, 0x41, 0x22, 0x14, 0x08 },   // >
        { 0x02, 0x01, 0x51, 0x09, 0x06 },   // ?
        { 0x32, 0x49, 0x59, 0x51, 0x3E },   // @
        { 0x7E, 0x11, 0x11, 0x11, 0x7E },   // A
        { 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B
        { 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C
        { 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D
        { 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E
        { 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F
        { 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G
        { 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H
        { 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I
        { 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J
        { 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K
        { 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L
        { 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M
        { 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N
        { 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O
        { 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P
        { 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q
        { 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R
        { 0x46, 0x49, 0x49, 0x49, 0x31 },   // S
        { 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T
        { 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U
        { 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V
        { 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W
        { 0x63, 0x14, 0x08, 0x14, 0x63 },   // X
        { 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y
        { 0x61, 0x51, 0x49, 0x45, 0x43 },   // Z
        { 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [
        { 0x55, 0x2A, 0x55, 0x2A, 0x55 },   // 55
        { 0x00, 0x41, 0x41, 0x7F, 0x00 },   // ]
        { 0x04, 0x02, 0x01, 0x02, 0x04 },   // ^
        { 0x40, 0x40, 0x40, 0x40, 0x40 },   // _
        { 0x00, 0x01, 0x02, 0x04, 0x00 },   // '
        { 0x20, 0x54, 0x54, 0x54, 0x78 },   // a
        { 0x7F, 0x48, 0x44, 0x44, 0x38 },   // b
        { 0x38, 0x44, 0x44, 0x44, 0x20 },   // c
        { 0x38, 0x44, 0x44, 0x48, 0x7F },   // d
        { 0x38, 0x54, 0x54, 0x54, 0x18 },   // e
        { 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f
        { 0x0C, 0x52, 0x52, 0x52, 0x3E },   // g
        { 0x7F, 0x08, 0x04, 0x04, 0x78 },   // h
        { 0x00, 0x44, 0x7D, 0x40, 0x00 },   // i
        { 0x20, 0x40, 0x44, 0x3D, 0x00 },   // j
        { 0x7F, 0x10, 0x28, 0x44, 0x00 },   // k
        { 0x00, 0x41, 0x7F, 0x40, 0x00 },   // l
        { 0x7C, 0x04, 0x18, 0x04, 0x78 },   // m
        { 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n
        { 0x38, 0x44, 0x44, 0x44, 0x38 },   // o
        { 0x7C, 0x14, 0x14, 0x14, 0x08 },   // p
        { 0x08, 0x14, 0x14, 0x18, 0x7C },   // q
        { 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r
        { 0x48, 0x54, 0x54, 0x54, 0x20 },   // s
        { 0x04, 0x3F, 0x44, 0x40, 0x20 },   // t
        { 0x3C, 0x40, 0x40, 0x20, 0x7C },   // u
        { 0x1C, 0x20, 0x40, 0x20, 0x1C },   // v
        { 0x3C, 0x40, 0x30, 0x40, 0x3C },   // w
        { 0x44, 0x28, 0x10, 0x28, 0x44 },   // x
        { 0x0C, 0x50, 0x50, 0x50, 0x3C },   // y
        { 0x44, 0x64, 0x54, 0x4C, 0x44 }    // z
    };
    
    void delay(void)
    {
      for(int i=0;i<100;i++)
      {
        asm("NOP");
      }
    }
    
    void transmitBit(unsigned char bit)
    {
      if(bit==1)PORT|=(1<<DATA);
      else PORT&=~(1<<DATA);
    
      PORT|=(1<<SDCLK);
      delay();
      PORT&=~(1<<SDCLK);
      delay();
    
    }
    
    void transmitByte(unsigned char byte)
    {
      PORT&=~(1<<LOAD);
    
      for (int x=0; x<=7;x++) 
      { 
        unsigned char bit=(byte>>x)&1; 
    	transmitBit(bit);
      }
    
      PORT|=(1<<LOAD);
    }
    
    void print(char *text)
    {
      unsigned char cursor=0;
      char *p=text;
      
      // reset ausführen
      PORT&=~(1<<RESET);
      delay();
      PORT|=(1<<RESET);
      delay();
      
      // initialisierung
      transmitByte(0b11000000);
    
      while(*p)
      {
        // aktuelles zeichen
    	unsigned char ch=*p;
    	
        // segment aktivieren (an cursorposition)
        unsigned char byte=0b10100000|cursor;
    	transmitByte(byte);
      
        // wenn das aktuelle zeichen kein anzeigbares zeichen ist
        if ( (ch < 0x20) || (ch > 0x7b) )
        {
            //  Convert to a printable character.
            ch = 92;
        }
      
        // nun umrechnen und ans display senden (7 zeilen)
    	for(unsigned char i=0;i<7;i++)
    	{
    	  byte=0;
    	  for(unsigned char j=0;j<5;j++)
    	  {
    	    byte|=((FontLookup[ch-32][j]>>i)&1)<<(4-j);
    	  }
    	  transmitByte(byte);
        }
    	
        // cursor um eine stelle nach vorne
        cursor++;
    	if(cursor>7)cursor=0;
    	
        // nächster buchstabe
        p++;
      }
    
    }
    
    int main(void) 
    {
      DDR=(1<<RESET)|(1<<SDCLK)|(1<<DATA)|(1<<LOAD);
    
      print("TEST!\0");
        
      while(1);
      
      return 0;
    }


    die funktion delay() wartet übrigens sehr grosszügig. da liesse sich noch entschieden was beschleunigen. so sollte es aber auch problemlos auf einem atmega mit 16MHz lauffähig sein.

    gruesse von der katz

  2. #2
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    30.09.2006
    Ort
    Hamburg
    Alter
    35
    Beiträge
    987
    Hi feine sache find ich gut die timings stehen auch recht genau auf der sbprojekt seite alerdinks sind diese schon recht harig
    Legastheniker on Bord !

    http://www.Grautier.com - Projektseite
    http://www.grautier.com/wiki/doku.php?id=bt-index - BT-BUS

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •