STK500 Taster + Taster über GUI

notify=status;

/*****************************************************

This program was produced by the

CodeWizardAVR V1.25.1 Standard

Automatic Program Generator

© Copyright 1998-2006 Pavel Haiduc, HP InfoTech s.r.l.

http://www.hpinfotech.com

Chip type           : ATmega8515L

Program type        : Application

Clock frequency     : 4,000000 MHz

Memory model        : Small

External SRAM size  : 0

Data Stack size     : 128

*****************************************************/

#include <mega8515.h>   

#include <stdio.h>

// Initialisierung Senden & Empfangen über USART-Schnittstelle

//------------------------------------------------------------------------

#define RXB8 1

#define TXB8 0

#define UPE 2

#define OVR 3

#define FE 4

#define UDRE 5

#define RXC 7

#define FRAMING_ERROR (1<<FE)

#define PARITY_ERROR (1<<UPE)

#define DATA_OVERRUN (1<<OVR)

#define DATA_REGISTER_EMPTY (1<<UDRE)

#define RX_COMPLETE (1<<RXC)

// USART Receiver buffer

#define RX_BUFFER_SIZE 8

char rx_buffer[RX_BUFFER_SIZE];

#if RX_BUFFER_SIZE<256

unsigned char rx_wr_index,rx_rd_index,rx_counter;

unsigned char notify=0x00;

#else

unsigned int rx_wr_index,rx_rd_index,rx_counter;

#endif

// This flag is set on USART Receiver buffer overflow

bit rx_buffer_overflow;

// USART Receiver interrupt service routine

interrupt [USART_RXC] void usart_rx_isr(void)

{  

char status,data;

status=UCSRA;

notify=status;

data=UDR;

if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)

   {

   rx_buffer[rx_wr_index]=data;   

   if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0;

   if (++rx_counter == RX_BUFFER_SIZE)

      {

      rx_counter=0;

      rx_buffer_overflow=1;

      };

   };

}

#ifndef _DEBUG_TERMINAL_IO_

// Get a character from the USART Receiver buffer

#define _ALTERNATE_GETCHAR_

#pragma used+ 

char getchar(void)

{

char data;

while (rx_counter==0);

data=rx_buffer[rx_rd_index];

if (++rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0;

#asm("cli")

--rx_counter;

#asm("sei")   

return data;

}

#pragma used-

#endif

// USART Transmitter buffer

#define TX_BUFFER_SIZE 8

char tx_buffer[TX_BUFFER_SIZE];

#if TX_BUFFER_SIZE<256

unsigned char tx_wr_index,tx_rd_index,tx_counter;

#else

unsigned int tx_wr_index,tx_rd_index,tx_counter;

#endif

// USART Transmitter interrupt service routine

interrupt [USART_TXC] void usart_tx_isr(void)

{

if (tx_counter)

   {

   --tx_counter;

   UDR=tx_buffer[tx_rd_index];

   if (++tx_rd_index == TX_BUFFER_SIZE) tx_rd_index=0;

   };

}

#ifndef _DEBUG_TERMINAL_IO_

// Write a character to the USART Transmitter buffer

#define _ALTERNATE_PUTCHAR_

#pragma used+      

void putchar(char c)

{

while (tx_counter == TX_BUFFER_SIZE);

#asm("cli")

if (tx_counter || ((UCSRA & DATA_REGISTER_EMPTY)==0))

   {

   tx_buffer[tx_wr_index]=c;

   if (++tx_wr_index == TX_BUFFER_SIZE) tx_wr_index=0;

   ++tx_counter;

   }

else

   UDR=c;

#asm("sei")

}

#pragma used-

#endif

//------------------------------------------------------------------------

// Declare your global variables here

void main(void)

{

// Declare your local variables here

unsigned char taster=0xFF; 

unsigned char led=0xFF;    

unsigned char led_alt=0xFF;

// Input/Output Ports initialization

PORTA=0xFF;

DDRA=0x00;

PORTB=0xFF;

DDRB=0xFF; 

// Timer/Counter 0 initialization

TCCR0=0x00;

TCNT0=0x00;

OCR0=0x00;

// Timer/Counter 1 initialization

TCCR1A=0x00;

TCCR1B=0x00;

TCNT1H=0x00;

TCNT1L=0x00;

ICR1H=0x00;

ICR1L=0x00;

OCR1AH=0x00;

OCR1AL=0x00;

OCR1BH=0x00;

OCR1BL=0x00;

// External Interrupt(s) initialization

MCUCR=0x00;

EMCUCR=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization

TIMSK=0x00;

// USART initialization

// Communication Parameters: 8 Data, 1 Stop, No Parity

// USART Receiver: On

// USART Transmitter: On

// USART Mode: Asynchronous

// USART Baud rate: 9600

UCSRA=0x00;

UCSRB=0xD8;

UCSRC=0x86;

UBRRH=0x00;

UBRRL=0x17; 

// Analog Comparator initialization

ACSR=0x80;

// Global enable interrupts

#asm("sei")

while (1)

      {     

      // B: LED         A: TASTER

     // solange notify kleiner 128: Board Modus 

     // d.h. abfrage ob erstes Bit in UCSRA gesetzt ist (Daten empfangen)

     while (notify<0x80){

      // LED: wenn änderung zum vorigen schleifendurchlauf wird LED status an PC geschickt

      led=PINB;    

      if (led_alt!=led){

        putchar(led);

      }   

      led_alt=led;   

    //Board mode

      PORTB=PINA; 

     } 

   // solange kein Taster gedrückt wird: PC Modus

     // hier kommt man nicht mehr raus! Idee: rauswurf durch tasterdruck am board...

     while (PINA==0xFF){

        // LED: wenn änderung zum vorigen schleifendurchlauf wird LED status an PC geschickt

      led=PINB;    

      if (led_alt!=led){

        putchar(led);

      }   

      led_alt=led;  

    //PC Mode

      PORTB=getchar();

     } 

     notify=0x00;

      };

}

PINA==0xFF

while (1)

      { 

// if irgendeinen taster gedrückt:

       if (PINA!=0xFF){

          PORTB=PINA;

          notify=0;

       }

// if was vom USART kommt (DIESEN ZUSTAND BEIBEHALTEN, bis was

// neues vom USART oder bis irgendeinen taster gedrückt

      if (notify>127){

         PORTB=getchar();

      }

};

while (1){    

      // B: LED         A: TASTER

    //   wenn USART neuen Status von PC empfängt, wird gui aktualisiert

    if (rx_counter){

        gui=getchar(); 

    }   

  // LED Status zusammensetzen aus Taster am Board und GUI Tasten

    led= (taster & gui); // entspricht: ~(~taster | ~gui)

    PORTB=led;

    taster=PINA; 

    // LED Ausgabe an PC schicken wenn LED Zustand sich geändert hat

    if (led_alt != led){ 

        putchar(led);

        led_alt = led;

    }          

};