Mega644 --> XMega256-A3U

Program I2C_BTR160_2;

{$NOSHADOW}
{ $WG}                     {global Warnings off}

Device = xmega256A3U, VCC=3.1;
{ $BOOTRST $20000}         {Reset Jump to $20000}

Import SysTick, LCDGraphic, SoftPWM, RTClock;

From System Import CharSet;

Define
  OSCtype        = int32MHz,
                   PLLmul=2,
                   prescB=1,
                   prescC=1;
  SysTick        = 10;             {msec}
  StackSize      = $0200, iData;
  FrameSize      = $0200, iData;

  LCDGraphic     = 160,160, 8;              { Display 160 x 160                }
  LCDgraphMode   = readonly, iData;
  DefCharSet     = 'Graphchars.pchr';
  GViewports     = 1, iData;
  TGraphStr      = 24;

  RTClock        = iData, DateTime;
  RTCSource      = SysTick;

  SoftPWMport    = PortD;                   { use PortA for PWM output         }
  SoftPWMtimer   = Timer_C0, 10;            { use timer2, PWM cycle time msec  }
  SoftPWMres     = 100;                     { PWM resolution is 127 Points     }
  SoftPWMchans   = 1, 4;                    { 1 channel, bit4 is the first bit }
Implementation

{$IDATA}

{--------------------------------------------------------------}
{ Type Declarations }
Type
{------------------------------------------------------------------------------}
{ Const Declarations }
Const
  elabbmp         : Array[1..(32*32 div 8)+2] of Byte = 'e-lab.pbmp';
{------------------------------------------------------------------------------}
{ Var Declarations }
Var
  //   /Reset PortD, 5
  //    A0    PortD, 6
  //   /WR    PortD, 7
  //   /CS    PortF, 1
  //   /RD    PortF, 0

  //LCD_DOut[@PortD]  : Byte;

  LCD_WR[@PortD,7]     : Bit;    //Write Signal
  LCD_RD[@PortF,0]     : Bit;    //Read Signal
  LCD_A0[@PortD,6]     : Bit;    //Select Command , 0  Command send  , 1 Data send
  LCD_CS[@PortF,1]     : Bit;    //Chip Select
  LCD_RST[@PortD,5]    : Bit;    //Reset
  //LCD_PWM[@PortD,4]    : Bit;    // HG-LED on

  Xpd, Ypd             : Integer;           // Rotate-Var Destination
  Xps, Yps             : Integer;           // Rotate-Var Source
{------------------------------------------------------------------------------}
{ Functions }
{$IDATA}
Procedure Init_Port;
  Begin
    PortD:=%11100000;      // /WR A0 /Reset PWM xxxx
    PortE:=%00000000;      // Datenport
    PortF:=%00000001;      // xxxxxx /CS /RD
    DDRD:=%11110000;
    DDRE:=%11111111;
    DDRF:=$00000011;
  End Init_Port;


Procedure Write_C(Daten:Byte);
  Begin
    LCD_A0:=0;                              // 0=Command
    LCD_WR:=0;
    PortE:=Daten;
    LCD_WR:=1;
  End Write_C;


Procedure Write_D(Daten:Byte);
  Begin
    LCD_A0:=1;                              //1=Data
    LCD_WR:=0;
    PortE:=Daten;
    LCD_WR:=1;
  End Write_D;


Procedure Backlight(Bright:Byte);
  Begin
    If Bright in [0..100]
      then
        SoftPWMArr[1]:=Bright;
      EndIf;
  End Backlight;


Procedure GraphInit;
  Begin
    // Der ST7529 ist ein LCD-Controller mit 32-Graustufen. Im vorliegenden Programm
    // wird das Display nur schwarz/weiß betrieben. Im Display-RAM und mit den folgenden
    // Einstellungen ist 1 Pixel = 1 Byte wobei $F8=Pixel ein und $00=Pixel aus.
    // %76543xxx Bit 3-7 = Graustufenwert     x=nicht verwendet

    LCD_RST:=0;
    MDelay(10);
    LCD_RST:=1;
    MDelay(10);

    Write_C($30);                    // Ext in
    Write_C($94);                    // Sleep out
    Write_C($D1);                    // Internal Osc on

    Write_C($20);                    // Power Control
    Write_D($08);                    //
    MDelay(10);                      //
    Write_C($20);                    // Power Control
    Write_D($0B);                    //
    MDelay(10);

    Write_C($81);                    // Electronic Volume Control - Contrast
    Write_D($30);                    // $38
    Write_D($04);                    // $04

    Write_C($CA);                    // Display Control
    Write_D($00);                    //
    Write_D($27);                    //
    Write_D($00);                    //

    Write_C($A7);                    // Normal Display

  // Mit den folgenden beiden Parametern $BB und $BC kann man die Scanreihenfolge
  // des Display-RAMs und die Orientierung festlegen.
  // Hierbei lohnt es sich bei fehlerhafter Displayausgabe ein bisschen zu spielen ;o)

    Write_C($BB);                    // COM Scan Direction
    Write_D($01);                    // $01 = Com0...Com79 + Com159...COM80

    Write_C($BC);                    // Data Scan Direction
    Write_D($02);                    // Line normal; Col reverse; $02 = rechts oben --> Pixel 0
    Write_D($01);                    // Segment Arrangement P3 P2 P1
    Write_D($02);                    // 32 Gray Scale, $02 = 3 Byte, 3 Pixel
                                     // ($01 = 2 Byte, 3 Pixel)

    Write_C($31);                    // Ext out

    Write_C($32);                    // Analog Circuit Set
    Write_D($00);                    // OSC frequency Adjustment
    Write_D($03);                    // Booster Efficiency Set
    Write_D($02);                    // Bias Setting

    Write_C($30);                    // Ext in

    Write_C($AF);                    // Display On
  End GraphInit;


{$D-}
UserDevice GraphIOS(cmd:Byte;Arg:Byte);
  Var MD : Byte;
  Begin
    If cmd=0
      then
        Write_C($15);        //Set Column Adress  , sichtbarer Bereich 16 - 72
        Write_D($10);
        Write_D($48);
        Write_C($75);        //Set Row Adress  , sichtbarer Bereich 0-159
        Write_D($00+Arg);
        Write_D($00+Arg);
        Write_C($5C);        //Befehl Write RAM bleibt aktiv bis ein nächstes Kommando kommt

        //Write_D($00);        // hierdurch wird das komplette Bild um 1 Pixel horizontal verschoben
        //Write_D($00);      // d.h. es kann die Ausgabe horizontal getrimmt werden.
      else
        For MD:=7 downto 0 do
          If Bit(Arg,MD)
            then
              Write_D($F8);  // Pixel on
            else
              Write_D($00);  // Pixel off
            EndIf;
          EndFor;
      EndIf;
  End GraphIOS;
{$D+}


Procedure Start;                            { Start des Programmes             }
  Begin
    gSetTextJustify(alHorCenter, alVertCenter);
    gSetTextMode(wmSetPix);
    gSetCharSetRam(false);
    gClrScr($00);
    gDispRefresh;
  End Start;


Procedure nRTCTickSecond;
  Var HMS : Integer;
  Begin
    gClrScr(0);
    HMS:=Integer(RTCgetSecond);
    RotatePnti(HMS*6,0,-69,Xps,Yps);
    gDrawCircle(79+Xps,79+Yps,10,$FF);
    gDrawString(78+Xps,79+Yps,1,1,TxtRot0,IntToStr(HMS));
    HMS:=Integer(RTCgetMinute);
    RotatePnti(HMS*6,0,-47,Xps,Yps);
    gDrawCircle(79+Xps,79+Yps,10,$FF);
    gDrawString(78+Xps,79+Yps,1,1,TxtRot0,IntToStr(HMS));
    HMS:=Integer(RTCgetHour);
    RotatePnti(HMS*30,0,-25,Xps,Yps);
    gDrawCircle(79+Xps,79+Yps,10,$FF);
    gDrawString(78+Xps,79+Yps,1,1,TxtRot0,IntToStr(HMS));
    HMS:=Integer(RTCgetDay);
    gDrawString(79,79,1,1,TxtRot0,IntToStr(HMS));
    gDispRefresh;
  End nRTCTickSecond;


Procedure Main;
  Var Counter : Integer;
  Begin
    For Counter:=1 to 7 do
      gDrawCircle(80,80,Counter*10,$FF);
      EndFor;
    gDrawLine(0,80,159,80,$FF);
    gDrawLine(80,0,80,159,$FF);
    gDrawLine(0,0,160,160,$FF);
    gDrawLine(0,160,160,0,$FF);
    gDrawString(120,66,5,5,TxtRot0,'C');
    gDrawString(130,90,5,5,TxtRot0,'H');

  End Main;
{------------------------------------------------------------------------------}
{ Main Program }
{$IDATA}

Begin
  EnableInts($87);
  Init_Port;
  Backlight(30);
  GraphInit;
  Start;
  Loop
    //gDrawCircle(80,80,81,$FF);
    gDrawCircle(80,80,80,$FF);
    gDrawCircle(80,80,79,$FF);
    Main;
    gDispRefresh;
    Endloop;

End I2C_BTR160_2.

Procedure Init_Port; 
  Begin 
    PortD:=%11100000;      // /WR A0 /Reset PWM xxxx 
    PortE:=%00000000;      // Datenport 
    PortF:=%00000001;      // xxxxxx /CS /RD 
    DDRD:=%11110000; 
    DDRE:=%11111111; 
    DDRF:=$00000011; 
  End Init_Port;