1:
2:
3:
4:
5:

// init SPI-Register im XMega
void spi_init(void){
    SPIC.CTRL =  SPI_MODE_0_gc | SPI_PRESCALER_DIV64_gc | (1<< SPI_ENABLE_bp) | (1<< SPI_MASTER_bp); // SPI-Clock 1MHz
    SPIC.INTCTRL = SPI_INTLVL_OFF_gc; // SPI-Interrupt deaktivieren 
  }

1:
2:
3:
4:

#define SPI_SS      4     // PC4 = SPI SS
#define SPI_MOSI    5     // PC5 = SPI MOSI
#define SPI_MISO    6     // PC6 = SPI MISO
#define SPI_SCK     7     // PC7 = SPI SCK

1:
2:
3:
4:

//PORTC für SPI-Komminikation mit Display konfigurieren
void spi_port_init(void){
  PORTC.DIRSET  = (1 << SPI_MOSI) | (1 << SPI_SCK) | (1<<SPI_SS);
  PORTC.OUTSET  = (1 << SPI_SS);     // SPI_SS Pin auf 1

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

// Ein Byte über SPI zum Display senden
void spi_send (unsigned char data){
  _delay_us(100);                 // warte bis Display bereit (nur notwendig wenn SPI-Datentransfer schneller als 100KHz)
  PORTC.OUTCLR = (1 << SPI_SS);   // SPI_SS Pin auf 0
  _delay_us(2);
  SPIC.DATA = data;               //Sendet ein Byte
  while(!(SPIC.STATUS & (1 << SPI_IF_bp))){} //Wartet bis Byte gesendet wurde
  _delay_us(2);
  PORTC.OUTSET = (1 << SPI_SS);   // SPI_SS Pin auf 1 
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:

#define  F_CPU 32000000UL    // Clock-Frequenz festlegen (wichtig für delay-Funktion)
#include <avr/io.h>
#include <util/delay.h>

#define SPI_SS      4     // PC4 = SPI SS
#define SPI_MOSI    5     // PC5 = SPI MOSI
#define SPI_MISO    6     // PC6 = SPI MISO
#define SPI_SCK     7     // PC7 = SPI SCK

// XMega CPU-Clock auf 32MHz einstelle
void clock_init(void){
      OSC.CTRL = OSC_RC32MEN_bm;
   // Warten bis Oszillator stabil ist
      while ((OSC.STATUS & OSC_RC32MRDY_bm) == 0);
   // System Clock selection
      CCP = CCP_IOREG_gc;
      CLK.CTRL = CLK_SCLKSEL_RC32M_gc;
   // DFLL ein (Auto Kalibrierung)
      DFLLRC32M.CTRL = DFLL_ENABLE_bm;
}

//PORTC für SPI-Komminikation mit Display konfigurieren
void spi_port_init(void){
  PORTC.DIRSET  = (1 << SPI_MOSI) | (1 << SPI_SCK)|(1<<SPI_SS);
  PORTC.OUTSET = (1 << SPI_SS);     // SPI_SS Pin auf 1 
}

// init SPI-Register im XMega
void spi_init(void){
    SPIC.CTRL =  SPI_MODE_0_gc | SPI_PRESCALER_DIV64_gc | (1<< SPI_ENABLE_bp) | (1<< SPI_MASTER_bp); // SPI-Clock 1MHz
    SPIC.INTCTRL = SPI_INTLVL_OFF_gc; // SPI-Interrupt deaktivieren 
  }

// Ein Byte über SPI zum Display senden
void spi_send (unsigned char data){
  _delay_us(100);        // warte bis Display bereit (nur notwendig wenn SPI-Datentransfer schneller als 100KHz)
  PORTC.OUTCLR = (1 << SPI_SS);  // SPI_SS Pin auf 0
  _delay_us(2);
  SPIC.DATA = data;        //Sendet ein Byte
  while(!(SPIC.STATUS & (1 << SPI_IF_bp))){} //Wartet bis Byte gesendet wurde
  _delay_us(2);
  PORTC.OUTSET = (1 << SPI_SS);     // SPI_SS Pin auf 1 
}

int main(void){
    clock_init();        // CPU-Clock 32MHz
    spi_port_init();    // SPI an PortC init 
    spi_init();            // SPI-Register init

    while(1){
      spi_send('A');
      _delay_ms(1000);
         
    }
}

1:
2:

// Initialisiere Touchkey (Schalter-Funktion)
    init_touchkey('K',60, 32, 100, 72, 0x01, 0x02, "OK", 2);

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

// init LCD-Touchkey 
void init_touchkey(char typ, unsigned char x1, unsigned char y1, unsigned char x2, unsigned char y2, unsigned char down_code,
 unsigned char up_code, char *string, unsigned char len){
    unsigned char buffer[9+len]; // Buffer Länge 
    buffer[0] = ESC;            // ESC
    buffer[1] = 'A';            // Befehl für Touch-Panel
    buffer[2] = typ;            // Funktion als Touch-Schalter
    buffer[3] = x1;                // Bereich von x1,y1 nach x2,y2 wird als Schalter definiert.
    buffer[4] = y1;
    buffer[5] = x2;
    buffer[6] = y2;
    buffer[7] = down_code;        // Rückgabewert beim Drücken der Taste
    buffer[8] = up_code;        // Rückgabewert beim Loslassen der Taste
    // inc Buffer-Pointer für Text-String
    volatile uint8_t i=0;        // "volatile" verhindert hier Optimierungsprobleme des Compilers
    for(i=0; i<len; i++)
    {
        buffer[9+i]=*string++;
    }
    buffer[9+i]=0;                    // Text-String mit einem 0 Byte abschließen
    SendData(buffer,10+len);        // Daten ans Display senden
    while(lcd_ack!=ACK){            // Quittierung vom Display auswerten
        _delay_ms(2000);            // wenn ungleich ACK dann nach 2sec Pause nochmal senden-
        SendData(buffer,10+len);    // bis ein ACK empfangen wurde    
    }
    lcd_ack=0;                        // Quittierung löschen
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

// Inhalt des Sendepuffers anfordern
void lcd_cmdreadpuf(void){
     lcd_cmdreadpuf1:
     PORTC.OUTCLR = (1 << SPI_SS);        // SPI_SS Pin auf 0
     spi_send(DC2);                        // send DC2
     spi_send(0x01);                    // send 1
     spi_send('S');                        // send 'S'
     spi_send(0x66);                    // send checksum (bcc)
     PORTC.OUTSET = (1 << SPI_SS);        // SPI_SS Pin auf 1
     _delay_us(12);                        // warten bis Daten im Display bereit zum senden
     PORTC.OUTCLR = (1 << SPI_SS);        // SPI_SS Pin auf 0
     spi_send(0x00);                    // ein Dummy-Byte senden
         while(SPIC.DATA!=ACK){            // Quittierung vom Display auswerten
         PORTC.OUTSET = (1 << SPI_SS);    // SPI_SS Pin auf 1
        _delay_ms(2000);                // wenn ungleich ACK dann nach 2sec Pause nochmal senden-
        goto lcd_cmdreadpuf1;            // bis ein ACK empfangen wurde    
    }
    PORTC.OUTSET = (1 << SPI_SS);        // SPI_SS Pin auf 1
    lcd_ack=0;                            // Quittierung löschen
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

// Daten aus dem Sendepuffer des Displays lesen    
void lcd_readpuf(void){
     uint8_t len;                            // Anzahhl Daten im Sendepuffer
     uint8_t bcc;                            // Prüfsumme
     uint8_t data;                            // Daten
     lcd_readpuf1:
     PORTC.OUTCLR = (1 << SPI_SS);            // SPI_SS Pin auf 0    
     spi_send(0x00);                        // ein Dummy-Byte senden
     if(SPIC.DATA!=DC1) goto lcd_readpuf1;    // Puffer leeren bis DC1 empfangen wurde
     bcc = bcc+DC1;                            // Zur Prüfsumme        
     spi_send(0x00);                        // ein Dummy-Byte senden
     len = SPIC.DATA;                        // Anzahl der Daten im Sendepuffer speichern (ohne Prüffsumme und DC1)
     if (len==0)                            // Prüfe Anzahl der Daten
     {
        touch_kennung = 0;                    // keine Daten vorhanden touch_kennung=0
        spi_send(0x00);                        // ein Dummy-Byte senden
        bcc = SPIC.DATA;                    // Prüefsumme verwerfen
        return;                                // Routine beenden
     }
     spi_send(0x00);                        // ein Dummy-Byte senden
     data = SPIC.DATA;                        // ESC lesen und verwerfen
     spi_send(0x00);                        // ein Dummy-Byte senden
     touch_kennung=SPIC.DATA;                // Touchkennung speichern
     switch(touch_kennung){
        case 'A':                            // Rückgabewert von Taster/Schalter
            spi_send(0x00);                    // ein Dummy-Byte senden
            touch_anz = SPIC.DATA;            // Rückgabewert: 0x01
            spi_send(0x00);                    // ein Dummy-Byte senden
            touch_code = SPIC.DATA;            // Rückgabewert: Tasten-Code    
            break;            
    }
    spi_send(0x00);                            // ein Dummy-Byte senden
    bcc = SPIC.DATA;                        // Prüefsumme verwerfen
    PORTC.OUTSET = (1 << SPI_SS);            // SPI_SS Pin auf 1 
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

// Touch-Taste im Display abfragen
void lcd_getkey(void){
     lcd_cmdreadpuf();            // Inhalt des Sendepuffers anfordern
     lcd_readpuf();                // Displaydaten lesen
}


while(1){  
    // Touch-Taste abfragen
    lcd_getkey();
        switch (touch_kennung){
            case 'A':
                    if (touch_code == 0x02){
                        lcd_font(4);
                        send_string("PRESS FOR LED ON ", 17, 32, 10);
                        LED_OUT = 0xFF;
                    }                    
                    if (touch_code == 0x01){
                        lcd_font(4);
                        send_string("PRESS FOR LED OFF", 17, 32, 10);
                        LED_OUT = 0x00;                                        
                    }                                            
            break;

                    }                    
     _delay_ms(50);     
    }        
}