-         
Ergebnis 1 bis 7 von 7

Thema: Oled Anzeige drehen ( von Portrait- ins Hochformat )

  1. #1
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    10.03.2005
    Ort
    Schifferstadt
    Alter
    36
    Beiträge
    318

    Oled Anzeige drehen ( von Portrait- ins Hochformat )

    Anzeige

    Hallo zusammen,

    ich habe hier ein Oled mit 102x80 Pixel mit dem SSD1325 Controller. Das anzeigen von Text usw. funktioniert. Aber leider nur im Portraitformat ( Quermodus ? ) Ich benötige die Anzeige im Hochformat. Der Bascom Code beschreibt das Display nur im Portraitformat. Im Anhang ist noch ein C-Schnipsel, indem das display im Hochformat beschrieben wird. Kann mir bitte jemand helfen, das ich auch in Bascom das Display im Hochformat beschreiben kann ?

    Hier der Bascom Code:

    Code:
    Declare Sub Oledinit()
    Declare Sub Cleardisplay()
    Declare Sub Filldisplay()
    Declare Sub Hline(byval Xpos As Byte , Byval Ypos As Byte , Byval Laenge As Byte)
    Declare Sub Vline(byval Xpos As Byte , Byval Ypos As Byte , Byval Laenge As Byte)
    Declare Sub Write_byte(byval Dat_or_cmd As Byte)
    Declare Sub Write_cmd(byval Command As Byte)
    Declare Sub Write_dat(byval Daten As Byte)
    Declare Sub Write_chars(byval Xpos As Byte , Byval Ypos As Byte , Byval Text As String)
    Declare Sub Write_pic_bw(byval Xpos As Byte , Byval Ypos As Byte)
    Declare Sub Write_pic_grey
    Declare Sub Array_erstellen(byval Text As String)
    
    Dim A As Integer
    Dim B As Byte
    Dim C As Byte
    Dim D As Word
    Dim E As Byte
    Dim G As Byte
    Dim Y As Byte
    Dim X As Byte
    Dim Z As Byte
    Dim Ziel As Byte
    Dim Xpos As Byte
    Dim Xpos_temp As Byte
    Dim Ypos As Byte
    Dim Pos As Integer
    Dim Tmp As Byte
    Dim Laenge As Byte
    Dim Zeile As Byte
    Dim Bitmode As Byte
    Dim Hoehe As Byte
    Dim Breite As Byte
    Dim Erg As Byte
    Dim Erg1 As Byte
    Dim Pic_daten_1 As Byte
    Dim Pic_daten_2 As Byte
    
    Dim Beginn_zeichen As Word
    Dim Ende_zeichen As Word
    Dim Db_zeiger As Word
    Dim Bz As Word
    Dim Ez As Byte
    Dim Ti As Byte
    Dim Tl As Byte
    Dim Tl2 As Word
    Dim Dat(102) As Byte                                        ' max. Stringlänge (=17) * 6 Bytes
    Dim Text As String * 17
    Dim Einzelzeichen As String * 1
    
    Waitms 100
    Call Oledinit
    Oled_12v = 1
    Waitms 100
    
    Do
      Call Cleardisplay
      Call Filldisplay
      Wait 3
      Call Cleardisplay
      Call Write_chars(0 , 0 , "*****************")
      Call Write_chars(0 , 1 , "* 102x80 Pixel  *")
      Call Write_chars(0 , 2 , "*               *")
      Call Write_chars(0 , 3 , "*  - SSD1325 -  *")
      Call Write_chars(0 , 4 , "*               *")
      Call Write_chars(0 , 5 , "* 16 Graustufen *")
      Call Write_chars(0 , 6 , "*               *")
      Call Write_chars(0 , 7 , "* 0123456789ABC *")
      Call Write_chars(0 , 8 , "*               *")
      Call Write_chars(0 , 9 , "*****************")
      Wait 3
      Call Cleardisplay
      Call Hline(7 , 12 , 100)
      Call Write_chars(0 , 3 , "  Jetzt auch in  ")
      Call Write_chars(0 , 5 , "BASCOM anwendbar ")
      Call Hline(7 , 60 , 100)
      Wait 3
      Call Cleardisplay
      Call Write_pic_bw(2 , 2)
      Wait 3
      Call Cleardisplay
      Call Write_pic_grey
      Wait 3
      Loop
    End
    
    
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' Sendet die Initialisierungs Bytes zum Oled Controller
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Oledinit
      Oled_res = 0
      Waitms 100
      Oled_res = 1
      Waitms 200
      Call Write_cmd(&H15)                                      ' / / Set Column Address
      Call Write_cmd(&H07)                                      ' / / Begin 7 Offset!
      Call Write_cmd(&H39)                                      ' / / End 57
      Call Write_cmd(&H75)                                      ' / / Set Row Address
      Call Write_cmd(&H00)                                      ' / / Begin 0
      Call Write_cmd(&H4f)                                      ' / / End 79
      Call Write_cmd(&H86)                                      ' / / Set Current Range 84h : Quarter , 85h : Half , 86h : Full
      Call Write_cmd(&H81)                                      ' / / Set Contrast Control
      Call Write_cmd(&H2d)
      Call Write_cmd(&Hbe)                                      ' / / Set Vcomh Voltage
      Call Write_cmd(&H00)
      Call Write_cmd(&Hbc)                                      ' / / Set Precharge Voltage
      Call Write_cmd(&H0f)
      Call Write_cmd(&Ha0)                                      ' / / Set Re -map
      Call Write_cmd(&H41)                                      ' / / Od. &H43
      Call Write_cmd(&Ha6)                                      ' / / Entire Display Off , All Pixels Turns Off
      Call Write_cmd(&Ha8)                                      ' / / Set Multiplex Ratio
      Call Write_cmd(&H4f)                                      ' / / Multiplex Ratio N From 16mux -80mux / / 80!
      Call Write_cmd(&Hb1)                                      ' / / Set Phase Length
      Call Write_cmd(&H22)
      Call Write_cmd(&Hb2)                                      ' / / Set Row Period
      Call Write_cmd(&H46)
      Call Write_cmd(&Hb0)                                      ' / / Set Pre -charge Compensation Enable
      Call Write_cmd(&H08)                                      '
      Call Write_cmd(&Hb4)                                      ' / / Set Pre -charge Compensation Level
      Call Write_cmd(&H00)                                      '
      Call Write_cmd(&Hb3)                                      ' / / Set Display Clock
      Call Write_cmd(&Ha0)
      Call Write_cmd(&Hbf)                                      ' / / Set Segment Low Voltage(vsl)
      Call Write_cmd(&H0d)                                      '
      Call Write_cmd(&Hb8)                                      ' / / Set Gray Scale Table
      Call Write_cmd(&H01)
      Call Write_cmd(&H11)
      Call Write_cmd(&H22)
      Call Write_cmd(&H32)
      Call Write_cmd(&H43)
      Call Write_cmd(&H54)
      Call Write_cmd(&H65)
      Call Write_cmd(&H76)
      Call Write_cmd(&Hae)                                      ' / / Set Display On
      Call Write_cmd(&Had)                                      ' / / Set Master Configuration
      Call Write_cmd(&H02)
      Waitms 75                                                 '; / / Dannach 75ms Pause!Print 7365us
      Call Write_cmd(&Ha4)                                      ' / / Normal Display
      Call Write_cmd(&Haf)                                      ' / / Set Display Off
      Call Write_cmd(&He3)                                      ' / / Nop
    End Sub
    
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' übergibt Daten für eine 1 Bit Grafik
    ' 1 Byte für 8 Pixel --> 1 Byte für 2 Pixel zum Display
    '- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Write_pic_bw(byval Xpos As Byte , Byval Ypos As Byte)
      D = 3
      Xpos_temp = Xpos
      Hoehe = Lookup(1 , Schiff)
      Breite = Lookup(2 , Schiff)
      Hoehe = Hoehe / 8
      Decr Hoehe
      Breite = Breite / 2
      Decr Breite
      For C = 0 To Hoehe
        For B = 0 To Breite
          Call Write_cmd(&H15)
          Erg = Xpos + 7
          Call Write_cmd(erg)
          Call Write_cmd(erg)
          Call Write_cmd(&H75)
          Erg = Ypos * 8
          Call Write_cmd(erg)
          Erg = Erg + 7
          Call Write_cmd(erg)
          Db_zeiger = D
          Pic_daten_1 = Lookup(db_zeiger , Schiff)
          Db_zeiger = D + 1
          Pic_daten_2 = Lookup(db_zeiger , Schiff)
        For Zeile = 0 To 7
          G = &H00
          If Pic_daten_1.zeile = 1 And Pic_daten_2.zeile = 1 Then G = &HFF
          If Pic_daten_1.zeile = 0 And Pic_daten_2.zeile = 1 Then G = &H0F
          If Pic_daten_1.zeile = 1 And Pic_daten_2.zeile = 0 Then G = &HF0
          Call Write_dat(g)
         Next
      Incr Xpos
      D = D + 2
      Next
      Xpos = Xpos_temp
      Incr Ypos
    Next
    End Sub
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' übergibt Daten für eine Graustufen Grafik
    ' 1 Byte für 8 Pixel --> 1 Byte für 2 Pixel zum Display
    '- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Write_pic_grey
      Hoehe = Lookup(1 , Python)
      Breite = Lookup(2 , Python)
      Pos = Hoehe * Breite
      Pos = Pos / 2
      Pos = Pos - 1
      Pos = Pos + 2
      Hoehe = Hoehe - 1
      For Z = 0 To Hoehe
        Call Write_cmd(&H15)
        Call Write_cmd(7)
        Erg = Breite / 2
        Erg = Erg - 1
        Erg = Erg + 7
        Call Write_cmd(erg)
        Call Write_cmd(&H75)
        Call Write_cmd(z)
        Call Write_cmd(z)
        Erg = Breite / 2
        Erg = Erg - 1
        For Y = 0 To Erg
          Tmp = Lookup(pos , Python)
          Erg1 = Tmp
          Shift Erg1 , Right , 4
          X = Erg1
          Shift Tmp , Left , 4
          Tmp = Tmp + X
          Call Write_dat(tmp)
          Pos = Pos - 1
        Next
      Next
    End Sub
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' übergibt Daten für max 17 5x7 Zeichen
    ' 8 Zeilen a 3 Bytes für ein Buchstabe
    '- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Write_chars(byval Xpos As Byte , Byval Ypos As Byte , Byval Text As String)
      Call Array_erstellen(text)
      Pos = 1
      B = 1
      Ypos = Ypos * 8
      Xpos = Xpos + 6
      For C = 1 To Tl
        Call Write_cmd(&H15)
        Erg = Xpos + B
        Call Write_cmd(erg)
        Erg = Erg + 2
        Call Write_cmd(erg)
        Call Write_cmd(&H75)
        Erg = Ypos
        Call Write_cmd(erg)
        Erg = Ypos + 7
        Call Write_cmd(erg)
        For Zeile = 0 To 7
          G = &H00
          If Dat(pos).zeile = 1 And Dat(pos + 1).zeile = 1 Then G = &HFF
          If Dat(pos).zeile = 0 And Dat(pos + 1).zeile = 1 Then G = &H0F
          If Dat(pos).zeile = 1 And Dat(pos + 1).zeile = 0 Then G = &HF0
          Call Write_dat(g)
          G = &H00
          If Dat(pos + 2).zeile = 1 And Dat(pos + 3).zeile = 1 Then G = &HFF
          If Dat(pos + 2).zeile = 0 And Dat(pos + 3).zeile = 1 Then G = &H0F
          If Dat(pos + 2).zeile = 1 And Dat(pos + 3).zeile = 0 Then G = &HF0
          Call Write_dat(g)
          G = &H00
          If Dat(pos + 4).zeile = 1 And Dat(pos + 5).zeile = 1 Then G = &HFF
          If Dat(pos + 4).zeile = 0 And Dat(pos + 5).zeile = 1 Then G = &H0F
          If Dat(pos + 4).zeile = 1 And Dat(pos + 5).zeile = 0 Then G = &HF0
          Call Write_dat(g)
        Next
        B = B + 3
        Pos = Pos + 6
      Next C
    End Sub
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' Sendet ein Daten Byte zum Oled Controller
    ' DC Auswahl
    '- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Write_dat(byval Daten As Byte)
      Oled_dc = 1
      Call Write_byte(daten)
    End Sub
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' Sendet ein Kommando Byte zum Oled Controller
    ' DC Auswahl
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Write_cmd(byval Command As Byte)
      Oled_dc = 0
      Call Write_byte(command)
    End Sub
    
    
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' Sendet seriell ein Daten oder Kommando Byte zum Oled Controller
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Write_byte(byval Dat_or_cmd As Byte)
      Disable Interrupts
      Reset Oled_cs
      Reset Oled_sdin
      Reset Oled_sclk
      Shiftout Oled_sdin , Oled_sclk , Dat_or_cmd , 1
      Enable Interrupts
      Reset Oled_sdin
      Set Oled_cs
    End Sub
    
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' Display löschen
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Cleardisplay
      Call Write_cmd(&H15)
      Call Write_cmd(7)
      Call Write_cmd(57)
      Call Write_cmd(&H75)
      Call Write_cmd(0)
      Call Write_cmd(79)
      For A = 0 To 4080
        Call Write_dat(0)
      Next
    End Sub
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' Display mit Muster füllen
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Filldisplay
      Call Write_cmd(&H15)
      Call Write_cmd(7)
      Call Write_cmd(57)
      Call Write_cmd(&H75)
      Call Write_cmd(0)
      Call Write_cmd(79)
      For A = 0 To 4080
        Call Write_dat(&Hf0)
      Next
    End Sub
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' zeichnet eine horizontale Linie
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Hline(byval Xpos As Byte , Byval Ypos As Byte , Byval Laenge As Byte)
      Call Write_cmd(&H15)
      Call Write_cmd(xpos)
      Laenge = Laenge / 2
      Ziel = Xpos + Laenge
      Call Write_cmd(ziel)
      Call Write_cmd(&H75)
      Call Write_cmd(ypos)
      Call Write_cmd(ypos)
      For A = 0 To Laenge
        Call Write_dat(&Hff)
      Next
    End Sub
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' zeichnet eine vertikale Linie
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Vline(byval Xpos As Byte , Byval Ypos As Byte , Byval Laenge As Byte)
      Call Write_cmd(&H15)
      Call Write_cmd(xpos)
      Call Write_cmd(xpos)
      Call Write_cmd(&H75)
      Call Write_cmd(ypos)
      Ziel = Ypos + Laenge
      Call Write_cmd(ziel)
      For A = 0 To Laenge
        Call Write_dat(&Hf0)
      Next
    End Sub
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    'Schreibt die Bytes für den Text in ein Array
    'Pro Zeichen 6 Bytes, max 17 Zeichen
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Sub Array_erstellen(byval Text As String)
      Tl = Len(text)
      B = 1
      For C = 1 To Tl
        Tl2 = Tl * 6
        Einzelzeichen = Mid(text , C , 1)
        Ez = Asc(einzelzeichen)
        Bz = Ez - 32
        Beginn_zeichen = Bz * 6
        Ende_zeichen = Beginn_zeichen + 5
        For Db_zeiger = Beginn_zeichen To Ende_zeichen
          Dat(b) = Lookup(db_zeiger , Zeichensatz)
          Incr B
        Next Db_zeiger
      Next C
    End Sub
    
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ' Zeichensatz in der Reihenfolge des ASCII Codes
    ' 6 Bytes pro Zeichen, erste Spalte immer leer
    ' - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Zeichensatz:
    Data 0 , 0 , 0 , 0 , 0 , 0                                  'Leerzeichen
    Hier der C-Code Schnipsel:

    Code:
    void PaintChar2(BYTE sign, BYTE column, BYTE row);
    ...
    
    
    //-------------------------------------------------------------------------------------------------
    // Zeichendarstellung im Display-Hochformat
    //
    // Hoehe x Breite: 102x80 Pixel
    //
    //    row: 0..11 = 12 Zeilen
    // column: 0..12 = 13 Spalten
    //
    //-------------------------------------------------------------------------------------------------
    void PaintChar2(BYTE sign, BYTE row, BYTE column) 
    {
    unsigned int pos;
    BYTE tmp, twopix, y;
    
      if (row>12) { row = 12; }
      if (column>11) { column = 11; }
    
      write_cmd(0x15);
      write_cmd(10+4*(11-column));
      write_cmd(10+4*(11-column)+3);   // 8 Spalten a 2 Pixel
      write_cmd(0x75);
      write_cmd(6*row);
      write_cmd(6*row+5);              // 6 Zeilen
    
      if ((sign<0x20) || (sign>0x7F)) { sign = 0x20; } 
      pos = 5*(sign-0x20);
    
      for (y=0; y<6; y++)
      {
        twopix = 0;
        tmp = pgm_read_byte(&code5x7[pos++]);
        if (y>4) { tmp = 0; }                        // leere Pixelspalte: sonst steht Zeichen an Zeichen!
        if (tmp & 0x80) { twopix |= 0xF0; }
        if (tmp & 0x40) { twopix |= 0x0F; }
        write_dat(twopix); twopix = 0;
        if (tmp & 0x20) { twopix |= 0xF0; }
        if (tmp & 0x10) { twopix |= 0x0F; }
        write_dat(twopix); twopix = 0;
        if (tmp & 0x08) { twopix |= 0xF0; }
        if (tmp & 0x04) { twopix |= 0x0F; }
        write_dat(twopix); twopix = 0;
        if (tmp & 0x02) { twopix |= 0xF0; }
        if (tmp & 0x01) { twopix |= 0x0F; }
        write_dat(twopix);
      }
    }
    Danke und Gruß BlaueLed

  2. #2
    Erfahrener Benutzer Lebende Robotik Legende Avatar von PICture
    Registriert seit
    10.10.2005
    Ort
    Freyung bei Passau in Bayern
    Alter
    66
    Beiträge
    10.996
    Hallo BlaueLed!

    Sorry für die "blöde" Antwort, aber ich kenne Bascom nicht und würde einfach das fast quadratische Display um 90° drehen ...

    MfG

  3. #3
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    10.03.2005
    Ort
    Schifferstadt
    Alter
    36
    Beiträge
    318
    Hi,

    so blöd ist die Idee garnicht. Jedoch ist das OLED schon fertig in einem Gehäuse verbaut. Also mechanisch drehen geht leider nicht.

    Gruß BlaueLED

  4. #4
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    16.02.2006
    Beiträge
    1.113
    Hallo BlaueLED,
    hast du mal mit dem Re-Map Befehl gespielt? Für mich klingt das so, als könntest du damit die Richtung ändern, in der die Daten auf das Display kommen. Evtl. kannst du auch mehrere von diesen Re-Maps hintereinander setzen.
    Bei meinem Nokia 6100 (wie das Display3000 1,5" LCD) habe ich darüber auch ein Drehen um 90°, 180° und 270° hinbekommen.
    Probier es mal aus.

  5. #5
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    10.03.2005
    Ort
    Schifferstadt
    Alter
    36
    Beiträge
    318
    Hallo For_ro,

    danke für die Info. Ich habe alle Re-Map Variablen durchlaufen lassen. Ich kann den Text nun Spiegelverkehrt anzeigen lassen. Auch geht es, den kompletten Display Inhalt um 180° zu drehen. Aber nur 90° geht nicht. Auch mehrere Re-Maps hintereinander brachte kein Erfolg. Es wird immer nur der erste Re-Map Befehl angenommen.

    Gruß BlaueLed

  6. #6
    Also den SSD1325 hab ich noch nicht im Einsat zgehabt, nunr den SSD1351. Die unterscheiden sich auf den ersten Blick aber nur in der Größe des Displays. Bei den remap Befehlen bist du eigentlich schon richtig. Du musst die Pointer Inkrementierung von horizontal auf vertikal stellen. Welches Bit das jetzt genau macht steht sicher im Datenblatt.

    Das mehrmals hintereinander zu machen bringt aber wirklich nichts, du überschreibt jedes mal die alten Einstellungen, kombinieren lässt sich da nichts.

  7. #7
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    16.02.2006
    Beiträge
    1.113
    Beim ssd1325 scheint das alles über die bits des Remap Kommandos zu gehen. Hast du da mal probiert, mehrer gleichzeitig zu setzen? Also Bit 0 + 4 setzen.
    Ich fand die Erklärung hier
    http://www.trulydisplays.com/oled/sp...%20SSD1325.pdf
    ganz hilfreich.

Berechtigungen

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