HIVE-Project

Tata: Premiere
Die erste Geräteassimilierung über den HiVe Erweiterungsbus hat statt gefunden.
Ich habe ein 16 BBP Handy Display angeschlossen welches über Administra angesprochen wird.

Morgen bekomme ich meine olle Cam wieder dann werde ich hier mal ein zwei Bilder hoch laden.

Hätte nicht gedacht wie viel Spass ein par bunte Pixel einem mit 44 Jahren machen können.

Grüsse Joshy

Hihi,

das wär doch noch was. Ein kleines Farb-TFT, das möglichst wenig Strom verbraucht. ( Handy Display müsste ideal sein, wenns nicht zu klein ist.. ) Und dann das ganze mit in mein C64- Gehäuse integrieren. Dann noch ein paar Akkus unter der Tastatur verstecken und wir hätten den ersten Hive- Mobile.

Wie Umfangreich müsste die Anbindung den sein, wenn man das Display an den Hive anstöpseln möchte ?

Grüße
Janaha

Da wäre es doch vielleicht einfacher, sich so einen Mini-LCD-Fernseher zu besorgen, ihm nötigenfalls einen Videoeingang zu verpassen und das Ganze an den TV-Out zu hängen? Dann bleibt der Erweiterungsbus frei ...

Wobei ein Handy-Display wahrscheinlich billiger zu bersorgen wäre. Alte Handys mit defektem Akku kriegt man ja nachgeschmissen. Aber die haben vermutlich nicht alle die gleiche Anschlussbelegung ...

Ich habe hier auch noch ein paar alte Handys. Da kann ich ja auch mal ein Display ausbauen.

Wann bekommen wir die Fotos zu sehen?

ben hat geschrieben:Ich habe hier auch noch ein paar alte Handys. Da kann ich ja auch mal ein Display ausbauen.

Wann bekommen wir die Fotos zu sehen?

Na dann wünsche ich Dir mal viel Spaß beim löten der Anschlüsse

Ich habe hier auch noch ein Handy-Display inkl. Steuereinheit mit ATMega128 .. hat echt ein cooles Farbbild, wäre mir aber als HIVE-Bildschirmersatz viel zu winzig.
Ich hatte vor mit dem Ding die RS232-Eingänge am HIVE Softwaremäßig umzuschalten (Miniatur-Relais), Temperaturen zu messen und was sonst noch so an Steuer-/Anzeigeaufgaben anfällt.
Der ATMega hat Power satt, genug Speicher und Pins .. da kann man schon einiges steuern.
Mit dem HIVE kann ich den ATMega über RS232, JTAG, 1-wire, usw. verbinden wenn ich will.

Jetzt muß ich nur noch irgendwann mal Zeit haben

Gruß.
Rainer

Das sieht mir nach dem Nokia 6100 Display aus
eine Hölle wenn man den Anschluss selber herstellen muss.

Ich habe 3 mal das LS020 diaplays vom Siemens Handy S65
das hat 176 x 132 Pixel bei 16 Bit Farbtiefe.

Ist zwar nicht wichtig aber die Bilder kommen noch.

Grüsse Joshy

DJLinux hat geschrieben:Das sieht mir nach dem Nokia 6100 Display aus
eine Hölle wenn man den Anschluss selber herstellen muss.

Ich habe 3 mal das LS020 diaplays vom Siemens Handy S65
das hat 176 x 132 Pixel bei 16 Bit Farbtiefe.

Ist zwar nicht wichtig aber die Bilder kommen noch.

Grüsse Joshy

Yep, ist ein 6110 - Display. 132x132, 65.536 Farben.
Der µC hat 126 kB Speicher, 50 freie Ports. Nettes kleines Ding, aber nicht unbedingt "billig". Aber der Entwickler ist cool, zuverlässig und hat mir mehrmals mit Sourcecode "ausgeholfen". Wen's interessiert --> http://www.display3000.com

Gruß.
Rainer

Ich habe das L S 0 2 0 genommen A ist es grösser B vieles lag noch im argen so das es noch ein kleines Abenteuer war dem LCD Controller Geheimnisse zu entlocken und C selbst ich als Lötkolben Einsteiger kann auch ohne Lupe ein Kabel anlöten.

Finanziell waren die Displays bei eBAY auch Schnäpchen 2,90€ 3,50€ und 4,50€ mit Versandtkosten 3 Displays für glatte 20€.

Die Ellen langen Initsequencen z.B. von und Christian Kranze und den diversen vom microcontroller.net Forum sind was für'n Popo. Ich hab das Teil ohne Ozzi oder Logic - Analyser "Re-Engineered" und zwar, wie sollte es bei mir auch anders sein, mit Software und Gehirnschmalz.

Es gibt für den Kontroller L R 3 8 8 2 6 nur ein Werbe *.pdf von SHARP ohne echte brauchbaren Informationen. Habe ALLE Google Einträge in einer Session von ca. 6 Stunden abgeklappert egal ob in Japan,China oder Polen alles endete immer mit dem einseitigem Werbe *.pdf und auf eMail Anfragen rückt SHARP auch kein Datasheet herraus weil das Display bzw. der Controller exklusiv für Siemens gefertigt wurde.

Anstatt wie wild und daher völlig planlos in irgend welchen Speicherzellen (die es nichtmals geben muss weil man zum Kontroller nur Senden und nicht Empfangen kann) wahlose Werte zu "Poken" habe ich meine alte Video Lib ausgekramt eine WebCam mit Stative auf das Display gerichtet und in Schleifen auf und absteigende Werte zum Display geschickt.

Wenn nun sich Irgend Etwas auf dem Display getan hat dann hat mein "sehendes" programm das registriert und mich ersteinmal mit einem nervendem Beep informiert. Entweder habe ich dann mir die nichts sagenden Hexcodes aufgeschrieben oder für später mit einem Vermerk in eine Datei schreiben lassen.

Das ging dann so weit das z.B. Irgend welcher Speicher- / Pixel- Müll z.B. auf dem Display anfing zu Scrollen oder schlagartig alle Pixel gleichzeitig in einer Farbe eingefärbt wurden oder das Display einfach nicht mehr reagierte und langsam alle Pixel verblasten.

Aber viele Register und dessen Bedeutung habe auf diese Weise näher eingränzen können und mit ein wenig Fleißarbeit genauer bestimmen können.

Daher ein kleines Abenteuer ...

bla bla bla ...

Grüsse Joshy

Nur mal zum Vergleich die Display Init Sequence mit 64 Bytes die alle anderen benutzen.
(Mann achte auch auf dessen Delay Zeiten in ms)

Vater; vergib Ihnen denn Sie wissen ja nicht Was Sie da tun

Die haben einfach die serielle Kommikation nach dem einschalten zwischen Handy und Display mit geschnitten und 1:1 übernommen ohne zu wissen was das Handy überhaupt gesendet hat vielleicht schicken die ja ein transparentes jpg eMail Symbol oder einen mouse cursor zum Handy

Ne so schlimm ist es nicht und sie haben auch schon eniges entschlüsseln können.

Code: Alles auswählen

__flash char init_array_0[20]=
{0xEF, 0x00, 0xEE, 0x04, 0x1B, 0x04, 0xFE, 0xFE,
0xFE, 0xFE, 0xEF, 0x90, 0x4A, 0x04, 0x7F, 0x3F, 
0xEE, 0x04, 0x43, 0x06};

__flash char init_array_1[46]=
{0xEF, 0x90, 0x09, 0x83, 0x08, 0x00, 0x0B, 0xAF,
0x0A, 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, 0x00, 
0xEF, 0x00, 0xEE, 0x0C, 0xEF, 0x90, 0x00, 0x80, 
0xEF, 0xB0, 0x49, 0x02, 0xEF, 0x00, 0x7F, 0x01,
0xE1, 0x81, 0xE2, 0x02, 0xE2, 0x76, 0xE1, 0x83,
0x80, 0x01, 0xEF, 0x90, 0x00, 0x00};
void ls020_init_lcd(void)
{
  
  ls020_wrcmd16(0xFDFD);
  ls020_wrcmd16(0xFDFD);
  
  __delay_cycles(F_CPU*0.068);// delay 68ms
  for (char i=0; i<20; i++)  { ls020_wrcmd8(init_array_0[i]); }
  __delay_cycles(F_CPU*0.010);// delay 10ms  
  for (char i=0; i<46; i++)  { ls020_wrcmd8(init_array_1[i]); }
}

und so wie es Opa Joshy macht
so kurz und knapp fast schon sexy

Code: Alles auswählen

  MMR90         ' Register Bank $90
  cmd16($EE_04) ' Clock und Timing einstellen
  cmd16($4A_04)
  cmd16($43_06)
  waitms(7) 
  MMR0C         ' Register Bank $0C 
  waitms(7)
  cmd16($80_01) ' Pixel Speichertransfer an

So langsam macht mir Drohne Joshy echt Angst. Irgendwann wird er mit seinem überlegenen Intellekt das ganze Kollektiv assimilieren und in etwas anderes, Unbekanntes, FURCHTERREGENDES verwandeln!

>

DJLinux hat geschrieben:... Ist zwar nicht wichtig aber die Bilder kommen noch ...

Hatte ich vor lauter OS Entwicklung ganz vergessen. Leider kann meine olle Webcam nicht das geniale scharfe Bild des Displays wieder geben.

Kuzes Video auf YouTube

Grüsse Joshy

PS. Ich poste mal den Code ist zwar nicht relevant wenn man das Display nicht hat
aber man kann z.B. sehen wie ich aus dem 16x32 ROM Font einen 8x16 Font mache.
Zu finden im Assembler Teil mit dem Label "cog_ROM_Char".

Title: S65_PASM_SPI.spin

Code: Alles auswählen

{{PASM S65 Interface}}
''*****************************************************************
''*  Propeller S65 LCD LS020xxx display interface                 *
''*  Author: DJLinux (d.j.peters at web dot de )                  *
''*****************************************************************
CON
  _clkmode = xtal1 + pll16x                           
  _xinfreq = 5_000_000
    
  #0
  JOB_NONE
  JOB_INIT
  JOB_CMD
  JOB_DATA
  JOB_DATA_BLK
  JOB_BIT_BLK
  JOB_ROM_CHAR
  JOB_STOP
   
VAR
  long CogNr
  long JobNr
  long Params1
  long Params2
  long Params3
  long Params4
  long Params5
  
PUB Init(_CS,_RS,_CLK,_DATA)
  ConfigStart(_CS,_RS,_CLK,_DATA)
  
  ' minimum config by D.J.Peters
  
  MMR90 
  Cmd16($EE_04)  ' start timiming
  Cmd16($4A_04)
  Cmd16($43_06)
  WaitMS(5)
  MMR00
  Cmd16($EE_0C)  ' end of timing
  MMR00          ' only dummy clocks 
  MMR00          ' only dummy clocks
  Cmd16($80_01)  ' memory transfer on
  MMR90
  Cmd16($00_00)
  
PUB Cmd8(Cmd)
  Params1 := Cmd
  Params2 := 8
  JobNr := JOB_Cmd 
  repeat until JobNr == JOB_NONE
  
PUB Cmd16(Cmd)
  Params1 := Cmd
  Params2 := 16 
  JobNr := JOB_Cmd
  repeat until JobNr == JOB_NONE
  
PUB Cmd32(Cmd)
  Params1 := Cmd
  Params2 := 32
  JobNr := JOB_Cmd
  repeat until JobNr == JOB_NONE
  
PUB Data8(data)
  Params1 := data
  Params2 := 8   
  JobNr   := JOB_DATA
  repeat until JobNr == JOB_NONE
                                         
PUB Data16(data)
  Params1 := data
  Params2 := 16   
  JobNr   := JOB_DATA
  repeat until JobNr == JOB_NONE
    
PUB Data32(data)
  Params1 := data
  Params2 := 32   
  JobNr := JOB_DATA
  repeat until JobNr == JOB_NONE
  
PUB PixelBlit(PixelColor,nPixels)
  Params1 := PixelColor
  Params2 := nPixels
  JobNr   := JOB_DATA_BLK
  repeat until JobNr== JOB_NONE
  
PUB BitBlit(pFirstByte,nBytes,fc,bc) 
  Params1 := pFirstByte
  Params2 := nBytes
  Params3 := fc
  Params4 := bc
  JobNr   := JOB_BIT_BLK
  repeat until JobNr== JOB_NONE

PUB RomChar(c,fc,bc) 
  Params1 := c
  Params2 := fc
  Params3 := bc
  JobNr   := JOB_ROM_CHAR
  repeat until JobNr== JOB_NONE
    
PUB MMR00
  Cmd16($EF_00) ' select memory mapped register in bank $00

PUB MMR90
  Cmd16($EF_90) ' select memory mapped register in bank $90

PUB MMRB0
  Cmd16($EF_B0) ' select memory mapped register in bank $B0    

PUB REG(r,v)
  Cmd8(r)
  Cmd8(v)     

PUB WaitMS(ms)| c
  c := CNT + CLKFREQ / 1000 * ms
  WaitCnt(c)
  
PRI ConfigStart(pCs,pRs,pClk,pDat)
  Params1 := pCs
  Params2 := pRs
  Params3 := pClk
  Params4 := pDat
  JobNr   := JOB_INIT     
  CogNr   := cognew(@cog_loop,@JobNr) + 1 
  repeat until JobNr == JOB_NONE  

DAT                     ORG 0

cog_loop                rdlong  job,par wz   ' get job id
              if_z      jmp     #cog_loop
 
                        cmp     job,#JOB_DATA wz
              if_z      jmp     #cog_Data

                        cmp     job,#JOB_BIT_BLK wz
              if_z      jmp     #cog_Bit_blk
              
                        cmp     job,#JOB_DATA_BLK wz
              if_z      jmp     #cog_Data_blk

                        cmp     job,#JOB_ROM_CHAR wz
              if_z      jmp     #cog_ROM_Char

                        cmp     job,#JOB_Cmd wz
              if_z      jmp     #cog_Cmd

                        cmp     job,#JOB_INIT wz 
              if_z      jmp     #cog_Init

                        cmp     job,#JOB_STOP wz
              if_z      jmp     #cog_stop
                                      
                        ' ignore unknow job 
                        jmp   #cog_loop

cog_ready               mov     ptr,par
                        mov     job,#JOB_NONE
                        wrlong  job,ptr
                        jmp     #cog_loop

cog_stop                cogid   job
                        cogstop job


' shiftout 8,16 or 32 bit data              
cog_Data                mov     ptr,par
                        add     ptr,#4          ' next param  
                        rdlong  value,ptr       ' read data

                        add     ptr,#4          ' get next param  
                        rdlong  nbits,ptr       ' (8,16,32)
                        mov     ptr,#32
                        sub     ptr,nbits wz       
                if_nz   shl     value,ptr       ' move to MSB bit 31
                        
                        mov     pin,#1 wz       ' set Z flag
                        muxz    outa,pm_cs      ' /CS low
                        muxz    outa,pm_rs      '  RS low


:cog_Data_loop          shl     value,#1 wc     ' move MSB in C flag
                        muxc    outa,pm_dat     ' send c flag
                        or      outa,pm_clk     ' clock high
                        xor     outa,pm_clk     ' clock Low
                        djnz    nbits,#:cog_Data_loop
                        xor     outa,pm_cs      ' /CS high
                                                           
                        jmp     #cog_ready
                        

' shift out a block of data 
cog_Data_blk            mov     ptr,par
                        add     ptr,#4          ' get next param  
                        rdlong  value,ptr       ' read 32 bit fill value
                                                 
                        add     ptr,#4          ' get next param
                        rdlong  nbits,ptr       ' number of loops
                        shl     nbits,#4        ' number of shifts
                                                
                        mov     pin,#1 wz       ' set Z flag
                        muxz    outa,pm_cs      ' /CS low !!!
                        muxz    outa,pm_rs      '  RS low  
                        
cog_Data_blk_loop       rol     value,#1 wc     ' move MSB in c flag
                        muxc    outa,pm_dat     ' send c flag
                        or      outa,pm_clk     ' clock high
                        xor     outa,pm_clk     ' clock Low
                        djnz    nbits,#cog_Data_blk_loop
                        
                        xor     outa,pm_cs      ' /CS high
                        jmp     #cog_ready
'#####################################################################                        
cog_Bit_blk             mov     ptr,par
                        add     ptr,#4          ' get next param  
                        rdword  pBits,ptr       ' read pointer on bits
                                                 
                        add     ptr,#4          ' get next param
                        rdlong  counter,ptr     ' number of loops
                                                
                        add     ptr,#4          ' get next param
                        rdword  fcol,ptr        ' fcolor
                        shl     fcol,#16
                        
                        add     ptr,#4          ' get next param
                        rdword  bcol,ptr        ' bcolor
                        shl     bcol,#16
                                                
                        mov     pin,#1 wz       ' set Z flag
                        muxz    outa,pm_cs      ' /CS low !!!
                        muxz    outa,pm_rs      '  RS low
                        mov     value,#0
                        
cog_BitByte_blk_loop    rdbyte  value,pBits
                        add     pBits,#1
                        mov     bits,value
                        shl     bits,#24
                        mov     nbits,#8       ' 1 byte
                        
cog_BitBit_blk_loop     shl     bits,#1 wc
                  if_nc mov     value,bcol
                  if_c  mov     value,fcol
                        mov     nbits2,#16
cog_BitColor_blk_loop   shl     value,#1 wc     ' move MSB in c flag
                        muxc    outa,pm_dat     ' send c flag
                        or      outa,pm_clk     ' clock high
                        xor     outa,pm_clk     ' clock Low
                        djnz    nbits2 ,#cog_BitColor_blk_loop
                        djnz    nbits  ,#cog_BitBit_blk_loop
                        djnz    counter,#cog_BitByte_blk_loop
                        
                        xor     outa,pm_cs      ' /CS high
                        jmp     #cog_ready
'#####################################################################
cog_ROM_Char            mov     ptr,par
                        add     ptr,#4          ' get next param
                        mov     pBits,#$80
                        shl     pBits,#8        ' $8000
                        mov     Value,#0  
                        rdbyte  Value,ptr       ' read char
                        mov     LSB,#1 
                        shr     Value,#1 wc     ' two chars per field
                  if_c  shl     LSB,#1
                        shl     Value,#7        ' chars*32
                        add     pBits,Value
                                                                                                
                        add     ptr,#4          ' get next param
                        rdword  fcol,ptr        ' fcolor
                        shl     fcol,#16
                        
                        add     ptr,#4          ' get next param
                        rdword  bcol,ptr        ' bcolor
                        shl     bcol,#16

                        mov     counter,#16     ' 32 longs = 1 Char 
                                                
                        mov     pin,#1 wz       ' set Z flag
                        muxz    outa,pm_cs      ' /CS low !!!
                        muxz    outa,pm_rs      '  RS low

cog_ROM_Char_Long_loop  rdlong  bits,pBits
                        add     pBits,#8        ' next second long
                        mov     nBits,#8        ' only 8 bits per line
                        mov     Mask,LSB        ' left or right char
cog_ROM_Char_Bit_loop   test    Bits,Mask wz
                  if_z  mov     value,bcol
                  if_nz mov     value,fcol
                        shl     Mask,#4
                        mov     nbits2,#16
cog_ROM_Char_Color_loop shl     value,#1 wc     ' move MSB in c flag
                        muxc    outa,pm_dat     ' send c flag
                        or      outa,pm_clk     ' clock high
                        xor     outa,pm_clk     ' clock Low
                        djnz    nbits2 ,#cog_ROM_Char_Color_loop
                        djnz    nbits  ,#cog_ROM_Char_Bit_loop
                        djnz    counter,#cog_ROM_Char_Long_loop
                        
                        xor     outa,pm_cs      ' /CS high
                        jmp     #cog_ready
'#####################################################################
                        
' shiftout 8,16 or 32 bit command            
cog_Cmd                 mov     ptr,par
                        add     ptr,#4          ' get next param  
                        rdlong  value,ptr       ' read Cmd

                        add     ptr,#4          ' get next param  
                        rdlong  nbits,ptr       ' (8,16,32)
                        mov     ptr,#32
                        sub     ptr,nbits wz       
                if_nz   shl     value,ptr       ' 24 or 16
                
                        mov     pin,#1 wz       ' set Z flag
                        muxz    outa,pm_cs      ' /CS low
                        or      outa,pm_rs      '  RS high
                         
:cog_Cmd_loop           shl     value,#1 wc     ' move MSB in c flag
                        muxc    outa,pm_dat     ' send MSB
                        or      outa,pm_clk     ' clock high
                        xor     outa,pm_clk     ' clock Low
                        djnz    nbits,#:cog_Cmd_loop
                        xor     outa,pm_cs      ' /CS high
                                                           
                        jmp     #cog_ready
                        
' config all pin masks
cog_Init                mov     ptr,par
                                                          
                        add     ptr,#4          ' get next param
                        rdlong  pin,ptr         ' /CS
                        mov     pm_cs, #1
                        shl     pm_cs,pin

                        add     ptr,#4          ' get next param
                        rdlong  pin,ptr         ' RS register select
                        mov     pm_rs, #1
                        shl     pm_rs,pin
                                                         
                        add     ptr,#4          ' get next param
                        rdlong  pin,ptr         ' Serial CLOCK
                        mov     pm_clk, #1
                        shl     pm_clk,pin
         
                        add     ptr,#4          ' get next param
                        rdlong  pin,ptr         ' Serial DATA
                        mov     pm_dat, #1
                        shl     pm_dat,pin
         
                        mov     pin,#1 wz       ' set z flag
                        muxz    outa,pm_dat     ' Pins[IDAT] := 0
                        muxnz   dira,pm_dat     ' Pins[IDAT] := 1

                        muxz    outa,pm_clk     ' Pins[ICLK] := 0
                        muxnz   dira,pm_clk     ' Pins[ICLK] := 1
    
                        'muxz    outa,pm_res     ' Pins[IRES] := 0 reset display
                        'muxnz   dira,pm_res     ' Pins[IRES] := 1
       
                        muxnz   outa,pm_cs      ' Pins[ICS ] := 1 deselect display
                        muxnz   dira,pm_cs      ' Pins[ICS ] := 1
  
                        muxnz   outa,pm_rs      ' Pins[IRS ] := 1 set RS hi
                        muxnz   dira,pm_rs      ' Pins[IRS ] := 1

                        jmp     #cog_ready
'#####################################################################                        
bits    res 1 ' one byte
pbits   res 1 ' pointer on bits
nbits   res 1 ' bit counter
nbits2  res 1 ' bit counter
fcol    res 1 ' foreground color
bcol    res 1 ' background color
counter res 1 ' loop counter
pin     res 1
delay   res 1 ' ticks of delay 
ptr     res 1 ' copy of PAR
job     res 1 ' curent job
value   res 1 ' data or command
mask    res 1
lsb     res 1
pm_dira res 1 ' mask of DIRA 
'pm_res  res 1 ' pin mask of /RESET
pm_rs   res 1 ' pin mask of  RS 
pm_cs   res 1 ' pin mask of /CS
pm_clk  res 1 ' pin mask of  CLK
pm_dat  res 1 ' pin mask of  DATA      

        FIT
}}

Title: S65.spin

Code: Alles auswählen

{{ S65 Interface demo }} 
''*****************************************************************
''*  Propeller S65 LCD LS020xx display interface                  *
''*  Author: DJLinux (d.j.peters at web dot de )                  *
''*****************************************************************
CON
  _clkmode = xtal1 + pll16x                           
  _xinfreq = 5_000_000

  #0,S65_RS,S65_CS,S65_CLK,S65_DAT
            
    
VAR byte  _LANDSCAPE
    word  fcolor,bcolor
    byte _R1,_R5,_RX1,_RY1,_RX2,_RY2,_WIDTH,_HEIGHT,_CX,_CY
    byte _ROMFONT,_FW,_FH
OBJ
  S65 : "S65_PASM_SPI"
  
PRI Portrait
  _LANDSCAPE:=FALSE
  S65.Cmd16($01_00)      
  S65.Cmd16($05_00)
  _RY1:=$A   
  _RY2:=$B
  _RX1:=$8
  _RX2:=$9
  _WIDTH := 132
  _HEIGHT:= 176
  _CX:=0
  _CY:=0
PRI Landscape
  _LANDSCAPE:=TRUE
  S65.Cmd16($01_80)      
  S65.Cmd16($05_04)
  _RY1:=$8   
  _RY2:=$9
  _RX1:=$A
  _RX2:=$B
  _WIDTH := 176
  _HEIGHT:= 132
  _CX:=0
  _CY:=0
  
PRI UseROMFont(boolean)
  _ROMFONT := boolean
  _FW:=8
  if _ROMFONT
    _FH:=16
  else
    _FH:=8
        
PRI PalMode(boolean)
  if boolean
    S65.Reg($04,%1) ' enable PAL332
  else
    S65.Reg($04,%0) ' enable RGB565 
     
PRI Inverse(boolean)
  S65.MMRB0
  if boolean
    S65.Reg($49,%11)
  else  
    S65.Reg($49,%10)
  S65.MMR90
   
PRI SetScrollPosition(Position)
  S65.Reg($11,Position)
  
PRI SetScrollRegion(FirstLine,NumberOfLines)
  S65.Reg($0F,FirstLine    ) 
  S65.Reg($10,NumberOfLines) 
 
PRI BPP16
  'S65.Cmd16($E80F)
  S65.Cmd16($E800)
   
PRI BPP8  
  'S65.Cmd16($E801)  
  S65.Cmd16($E802)

PRI DisplayOff(WhiteFlag)
  if (WhiteFlag)
    S65.Cmd16($00_80)
  else  
    S65.Cmd16($00_40)
    
PRI DisplayOn
  S65.Cmd16(00_00)
   
PRI SetOrigin(x,y)
  S65.Reg($07,y) 
  S65.Reg($08,x)  
         
PUB main | r,g,b,x,y,m
  S65.Init(S65_CS,S65_RS,S65_CLK,S65_DAT)
  _FW:=8
  _FH:=8
  fColor:=RGB555(31,31,31)
  bColor:=RGB555( 0, 0, 0)
  
UseROMFont(TRUE)
  
repeat
  'bcolor:=RGB555(cnt?,?cnt,cnt?) 
  Portrait
  NewFrame
  repeat 22
    print(@msgP)
    fcolor:=RGB555(r,g,b)
    r+=1
    g+=2
    b+=3
  ShowFrame  
  S65.WaitMS(2000)
  
  Landscape
  NewFrame
   repeat 16
     printnl(@msgL)
     fcolor:=RGB555(r,g,b)
     r+=2
     g+=3
     b+=1 
  ShowFrame  
  S65.WaitMS(2000)
    
  NewFrame
  m:=$0  
  repeat y from 0 to 15
    repeat x from 0 to 21
      _cx:=_FW*x
      _cy:=_FH*y
      PrintChar(m++)
      fcolor:=RGB555(r,g,b)
      r+=3
      g+=1
      b+=2 
  ShowFrame
  S65.WaitMS(3000)
  
  r:=8
  g:=8
  b:=8
  repeat 2
    repeat m from 32 to 2
      r+=1
      g+=3
      b+=2
      fcolor:=RGB555(r,g,b)
      NewFrame
        repeat x from 0 to _WIDTH-1 step m
          VLine(x)
        repeat y from 0 to _HEIGHT-1 step m
          HLine(y)  
      ShowFrame
    repeat m from 2 to 6
      r+=1
      g+=3
      b+=2
      fcolor:=RGB555(r,g,b)
      NewFrame
        repeat x from 0 to _WIDTH-1 step m
          VLine(x)
        repeat y from 0 to _HEIGHT-1 step m
          HLine(y)  
      ShowFrame    
  S65.WaitMS(1000)

PRI NewFrame
  S65.Reg($02,5)
  S65.WaitMS(20)
  Cls16(bcolor)
 
PRI ShowFrame
  S65.Reg($02,0)

PRI RGB8(c)
  return (c & %1110_0000)<<13 | (c &= %0001_1100)<<5 | (c &= %0000_0011)<<3

PRI RGB332(r,g,b)
  return (r & %0000_0111)<<13 | (g &= %0000_0111)<<8 | (b &= %0000_0011)<<3

PRI RGB555(r,g,b)
  return (r & %0001_1111)<<11 | (g &= %0001_1111)<<6 | (b &= %0001_1111)    

PRI RGB565(r,g,b)
  return (r & %0001_1111)<<11 | (g &= %0011_1111)<<5 | (b &= %0001_1111)

PRI RGB888(r,g,b)
  return (r & %1111_1000)<< 8 | (g & %1111_1100) <<3 | (b & %1111_1000) >> 3  
  
PRI Plot(x,y,color) | i
  SetOrigin(x,y)
  repeat 7
    S65.data16(color)

PRI SetArea(x,y,w,h) | y1,y2
  if _LANDSCAPE
    y1:=131-y
    y2:=y1 -h
  else
    y1:=y
    y2:=y1+h-1
  S65.Reg(_RY1,y1)   
  S65.Reg(_RY2,y2)
  S65.Reg(_RX1,x)
  S65.Reg(_RX2,x+w-1)  
  
PRI Cls16(color)
  _CX := 0
  _CY := 0
  SetArea(0,0,_Width,_Height)
  color := color << 16 | color ' 16 -> 32 bit
  S65.PixelBlit(color,_WIDTH*_HEIGHT)
  
PRI Cls8(color)
  color := color <<  8 | color ' 8 -> 16 bit
  color := color << 16 | color '16 -> 32 bit  
  S65.PixelBlit(color,176*132>> 2) ' / 4 = number of longs
  
PRI PrintChar(char) | adr,bits
  SetArea(_CX,_CY,_FW,_FH)
  if _ROMFONT
    S65.ROMChar(char,fcolor,bcolor)
  else
    char-=14
    adr  := char<<3 
    adr  += @font
    S65.BitBlit(adr,8,fcolor,bcolor)
        
PRI Print(pText) | l,char
  l := StrSize(pText)
  if (l<1)
    return
  repeat l
    char:=byte[pText++]
    case char
      0..13:
      
      14..127:
        PrintChar(char)
    
    _CX+=_FW
    if (_CX+_FW)>_Width
      _CX:=0
      _CY+=_FH
      if (_CY+_FH)>_Height
        _CY-=_FH
        
PRI PrintNL(pText)
  Print(pText)
  _CX:=0
  _CY+=_FH
  if (_CY+_FH)>_Height
    _CY-=_FH
    
PRI HLine(y)
  SetArea(0,y,_WIDTH,1)
  S65.PixelBlit(fcolor,_WIDTH)
  
PRI VLine(x)
  SetArea(x,0,1,_HEIGHT)
  S65.PixelBlit(fcolor,_HEIGHT)  
           
DAT       ORG 0
msgL      byte "Landscape",0
msgP      byte "Portrait Portrait ",0
msg1      byte "0123456789",0
msg2      byte "ABCDEFGHIJ",0
msg3      byte "KLMNOPQRST",0
msg4      byte "UVWXYZabcd",0
msg5      byte "defghijklm",0
msg6      byte "nopqrstuvw",0
msg7      byte "xyz",0
msg8      byte "^!",34,"$%",0
msg9      byte "&/()=?{}[]",0
messages  word @msg1, @msg2, @msg3, @msg4
          word @msg5, @msg6, @msg8, @msg9

HIVE-Project

Premiere

Premiere

Re: Premiere

Re: Premiere

Re: Premiere

Re: Premiere

Re: Premiere

Re: Premiere

Re: Premiere

Re: Premiere

Re: Premiere