SPI an SCK keine Frequenz

[Paul (Gast)]

Hallo Forum,

ich bin gerade dabei einen Atmega16 im Verbund mit einem ENC60J28 zu 
betrieben. Die Schaltung ist aufgebaut, die Status LED an der MAGJack 
leuchtet, auch die Sende/Empfangs LED Idelt. Leider kommen leider 
scheint die Kommunikation zum Atmega noch nicht zu funktionieren. Auf 
der Fehlersuche habe ich entdeckt, dass ich an SCK keine Frequenz 
anliegen haben. Die Frage ist nur wieso. Momentan weis ich nicht weiter.

Anbei der Schaltplan und die Programmteile.
Vielleicht könnt ihr helfen?

SPI Einstellungen:

SPCR |= 1<<MSTR 
SPCR |= 1<<SPE;
SPSR |= 1<<SPI2X

Frequenz --> intern 8Mhz

/*  ##################################
  -Der buffer ist in stack.h definiert
   er ist in der Grösse ziemlich variabel,
   wenn man nicht gerade TCP verwendet,
   dann sollte auch eine Buffergrösse von
   256 Reichen, für nur arp und udp evt
   sogar 128
  -Ip & Mac wird in stack.c festgelegt!
  -der zu verwendende Pin für /CS wird
   am Anfang von enc28h60.h festgelegt
  ####################################
*/
#include <avr/io.h>
#include "stack.h"
#include "enc28j60.h"


#define TERMINATE 1
#define DONT_TERMINATE 0

/*einfache memcpy*/ 
void printinbuffer(uint8_t *buff,uint8_t *text,uint8_t terminate){
  while(*text){
    *buff++ = *text++;
  }
  if(terminate) *buff++ = 0x00;
}


/*  einfache strcmp, zwecks Lerneffekt auch selbst gemacht*/
uint8_t compare(uint8_t *buffone, uint8_t *bufftwo){
  
  uint8_t counterone=0,countertwo=0;
  while(*bufftwo){
    if(*buffone++ == *bufftwo++){counterone++;}
    countertwo++;
  }
  if(counterone==countertwo) return(1);
  return(0);

}


int main(void){

  
  unsigned int packet_lenght;
  
  
  /*ENC Initialisieren*/
  enc28j60Init();
  //Mac Adresse setzen(stack.h, dort wird auch die Ip festgelegt)
  nicSetMacAddress(mymac);
  
  /*  Leds konfigurieren
    LEDA : Link status
    LEDB : Receive activity
    Led Settings : enc28j60 datasheet, page 11*/
  
  enc28j60PhyWrite(0x14,0b0000010000100000);
  
  /*  Leds konfigurieren
    LEDA : Link status
    LEDB : Blink Fast
    Led Settings : enc28j60 datasheet, page 11
    Auskommentieren, wenn mans lieber blinken sieht ;-)    */
  
  //enc28j60PhyWrite(0x14,0b0000010000100000);

  
  while(1){
  //Buffer des Enc's abhohlen :-)
  packet_lenght = enc28j60PacketReceive(BUFFER_SIZE, buffer);
    
    /*Wenn ein Packet angekommen ist, ist packet_lenght =! 0*/
    if(packet_lenght){
    
    
      /*Ist das Packet ein Broadcast packet, vom Typ Arp und an unsere Ip gerichtet?*/
      if(Checkbroadcast() && Checkarppackage() && Checkmyip()){
            arp(packet_lenght, buffer);
      }
  
      /*Ist das Packet kein Broadcast, sondern explizit an unsere mac adresse gerichtet?*/
      if(Checkmymac()){
        
        /*Handelt es sich um ein ICMP Packet? ->beantworten (Pong)*/
        if (buffer[IP_TYPEFIELD] == TYPE_ICMP)icmp(packet_lenght,buffer);
        
        
        /*Handelt es sich um ein UDP Packet, das auf Port 85 reinkommt?*/
        if(buffer[IP_TYPEFIELD] == TYPE_UDP && buffer[UDP_PORT_L] == 85){  
          
          /*  Folgendes dient bloss als Anwendungsbeispiel, 
            die empfangenen Daten liegen im buffer ab adresse UDP_DATA
            und können natürlich auch für ganz andere Zweche verwendet
            werden.
            TODO: -Funktion um nicht nur auf UDP Packete zu antworten,
                 sondern auch welche zu erzeugen
                -TCP(muss ich erst noch verstehen :-) )
          */
          
          if(compare(&buffer[UDP_DATA], "test")){
            
            printinbuffer(&buffer[UDP_DATA], "Das Test Packetchen ist angekommen :-)",TERMINATE);
            //Die Länge 38 bezieht sich hier nur auf die Nutzdaten, headerlänge etc wird von der
            //Udp Funktion natürlich selbst übernommen...
            udp(38,buffer); 
          }
          
        }
  
      }
      
    }
  
  
  }
  
  return (1);
}

/*! \file enc28j60.c \brief Microchip ENC28J60 Ethernet Interface Driver. */
//*****************************************************************************
//
// File Name  : 'enc28j60.c'
// Title    : Microchip ENC28J60 Ethernet Interface Driver
// Author    : Pascal Stang (c)2005
// Created    : 9/22/2005
// Revised    : 9/22/2005
// Version    : 0.1
// Target MCU  : Atmel AVR series
// Editor Tabs  : 4
//
// Description  : This driver provides initialization and transmit/receive
//  functions for the Microchip ENC28J60 10Mb Ethernet Controller and PHY.
// This chip is novel in that it is a full MAC+PHY interface all in a 28-pin
// chip, using an SPI interface to the host processor.
//
//*****************************************************************************

#include "global.h"
//#include "timer.h"
//#include "rprintf.h"

#include "enc28j60.h"
#include <avr/io.h>


u08 Enc28j60Bank;
u16 NextPacketPtr;
#define ENC28J60_CONTROL_PORT  PORTD
#define ENC28J60_CONTROL_DDR  DDRD
#define ENC28J60_CONTROL_CS    4

#define F_CPU          8000000                   /* Processor Speed */
#define CYCLES_PER_US   ((F_CPU+500000)/1000000)   /* cpu cycles per microsecond */

void delay(unsigned short us) 
{
    unsigned short  delay_loops;
    register unsigned short  i;

    delay_loops = (us+3)/5*CYCLES_PER_US; // +3 for rounding up (dirty) 

  // one loop takes 5 cpu cycles 
    for (i=0; i < delay_loops; i++) {};
} 

void nicSetMacAddress(u08* macaddr)
{
  // write MAC address
  // NOTE: MAC address in ENC28J60 is byte-backward
  enc28j60Write(MAADR5, *macaddr++);
  enc28j60Write(MAADR4, *macaddr++);
  enc28j60Write(MAADR3, *macaddr++);
  enc28j60Write(MAADR2, *macaddr++);
  enc28j60Write(MAADR1, *macaddr++);
  enc28j60Write(MAADR0, *macaddr++);
}





u08 enc28j60ReadOp(u08 op, u08 address)
{
  u08 data;
   
  // assert CS
  ENC28J60_CONTROL_PORT &= ~(1<<ENC28J60_CONTROL_CS);
  
  // issue read command
  SPDR = op | (address & ADDR_MASK);
  while(!(SPSR & (1<<SPIF)));
  // read data
  SPDR = 0x00;
  while(!(SPSR & (1<<SPIF)));
  // do dummy read if needed
  if(address & 0x80)
  {
    SPDR = 0x00;
    while(!(inb(SPSR) & (1<<SPIF)));
  }
  data = SPDR;
  
  // release CS
  ENC28J60_CONTROL_PORT |= (1<<ENC28J60_CONTROL_CS);

  return data;
}

void enc28j60WriteOp(u08 op, u08 address, u08 data)
{
  // assert CS
  ENC28J60_CONTROL_PORT &= ~(1<<ENC28J60_CONTROL_CS);

  // issue write command
  SPDR = op | (address & ADDR_MASK);
  while(!(SPSR & (1<<SPIF)));
  // write data
  SPDR = data;
  while(!(SPSR & (1<<SPIF)));

  // release CS
  ENC28J60_CONTROL_PORT |= (1<<ENC28J60_CONTROL_CS);
}

void enc28j60ReadBuffer(u16 len, u08* data)
{
  // assert CS
  ENC28J60_CONTROL_PORT &= ~(1<<ENC28J60_CONTROL_CS);
  
  // issue read command
  SPDR = ENC28J60_READ_BUF_MEM;
  while(!(SPSR & (1<<SPIF)));
  while(len--)
  {
    // read data
    SPDR = 0x00;
    while(!(SPSR & (1<<SPIF)));
    *data++ = SPDR;
  }  
  // release CS
  ENC28J60_CONTROL_PORT |= (1<<ENC28J60_CONTROL_CS);
}

void enc28j60WriteBuffer(u16 len, u08* data)
{
  // assert CS
  ENC28J60_CONTROL_PORT &= ~(1<<ENC28J60_CONTROL_CS);
  
  // issue write command
  SPDR = ENC28J60_WRITE_BUF_MEM;
  while(!(SPSR & (1<<SPIF)));
  while(len--)
  {
    // write data
    SPDR = *data++;
    while(!(SPSR & (1<<SPIF)));
  }  
  // release CS
  ENC28J60_CONTROL_PORT |= (1<<ENC28J60_CONTROL_CS);
}

void enc28j60SetBank(u08 address)
{
  // set the bank (if needed)
  if((address & BANK_MASK) != Enc28j60Bank)
  {
    // set the bank
    enc28j60WriteOp(ENC28J60_BIT_FIELD_CLR, ECON1, (ECON1_BSEL1|ECON1_BSEL0));
    enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, (address & BANK_MASK)>>5);
    Enc28j60Bank = (address & BANK_MASK);
  }
}

u08 enc28j60Read(u08 address)
{
  // set the bank
  enc28j60SetBank(address);
  // do the read
  return enc28j60ReadOp(ENC28J60_READ_CTRL_REG, address);
}

void enc28j60Write(u08 address, u08 data)
{
  // set the bank
  enc28j60SetBank(address);
  // do the write
  enc28j60WriteOp(ENC28J60_WRITE_CTRL_REG, address, data);
}



void enc28j60PhyWrite(u08 address, u16 data)
{
  // set the PHY register address
  enc28j60Write(MIREGADR, address);
  
  // write the PHY data
  enc28j60Write(MIWRL, data);  
  enc28j60Write(MIWRH, data>>8);

  // wait until the PHY write completes
  while(enc28j60Read(MISTAT) & MISTAT_BUSY);
}

void enc28j60Init(void)
{
  // initialize I/O

  ENC28J60_CONTROL_DDR |= 1<<ENC28J60_CONTROL_CS;
  ENC28J60_CONTROL_PORT |= 1<<ENC28J60_CONTROL_CS;
  

  /*
  PORTB |= 1<<PB5; //SCK HI
  DDRB  |= 1<<PB2 |1<<PB3 | 1<<PB5; // mosi, sck, ss output
  DDRB  &= ~(1<<PB4); // miso input
  */
    
  PORTB |= 1<<PB7; //SCK HI
  DDRB  |= 1<<PB4 |1<<PB5 | 1<<PB7; // mosi, sck, ss output
  DDRB  &= ~(1<<PB6); // miso input

  //SS muss out sein, damit nicht auf Slave gewechselt wird

  // initialize SPI interface
  // master mode und /2x takt (klappt auch wenn der mega8 mit 16mhz läuft !!)
  SPCR |= 1<<MSTR 
  SPCR |= 1<<SPE;
  SPSR |= 1<<SPI2X
  
  

  // perform system reset
  enc28j60WriteOp(ENC28J60_SOFT_RESET, 0, ENC28J60_SOFT_RESET);
  // check CLKRDY bit to see if reset is complete
  delay(50);
  while(!(enc28j60Read(ESTAT) & ESTAT_CLKRDY));

  // do bank 0 stuff
  // initialize receive buffer
  // 16-bit transfers, must write low byte first
  // set receive buffer start address
  NextPacketPtr = RXSTART_INIT;
  enc28j60Write(ERXSTL, RXSTART_INIT&0xFF);
  enc28j60Write(ERXSTH, RXSTART_INIT>>8);
  // set receive pointer address
  enc28j60Write(ERXRDPTL, RXSTART_INIT&0xFF);
  enc28j60Write(ERXRDPTH, RXSTART_INIT>>8);
  // set receive buffer end
  // ERXND defaults to 0x1FFF (end of ram)
  enc28j60Write(ERXNDL, RXSTOP_INIT&0xFF);
  enc28j60Write(ERXNDH, RXSTOP_INIT>>8);
  // set transmit buffer start
  // ETXST defaults to 0x0000 (beginnging of ram)
  enc28j60Write(ETXSTL, TXSTART_INIT&0xFF);
  enc28j60Write(ETXSTH, TXSTART_INIT>>8);

  // do bank 2 stuff
  // enable MAC receive
  enc28j60Write(MACON1, MACON1_MARXEN|MACON1_TXPAUS|MACON1_RXPAUS);
  // bring MAC out of reset
  enc28j60Write(MACON2, 0x00);
  // enable automatic padding and CRC operations
  enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, MACON3, MACON3_PADCFG0|MACON3_TXCRCEN|MACON3_FRMLNEN);

  // set inter-frame gap (non-back-to-back)
  enc28j60Write(MAIPGL, 0x12);
  enc28j60Write(MAIPGH, 0x0C);
  // set inter-frame gap (back-to-back)
  enc28j60Write(MABBIPG, 0x12);
  // Set the maximum packet size which the controller will accept
  enc28j60Write(MAMXFLL, MAX_FRAMELEN&0xFF);  
  enc28j60Write(MAMXFLH, MAX_FRAMELEN>>8);

  // do bank 3 stuff
  // write MAC address
  // NOTE: MAC address in ENC28J60 is byte-backward
  enc28j60Write(MAADR5, ENC28J60_MAC0);
  enc28j60Write(MAADR4, ENC28J60_MAC1);
  enc28j60Write(MAADR3, ENC28J60_MAC2);
  enc28j60Write(MAADR2, ENC28J60_MAC3);
  enc28j60Write(MAADR1, ENC28J60_MAC4);
  enc28j60Write(MAADR0, ENC28J60_MAC5);

  // no loopback of transmitted frames
  enc28j60PhyWrite(PHCON2, PHCON2_HDLDIS);

  // switch to bank 0
  enc28j60SetBank(ECON1);
  // enable interrutps
  enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, EIE, EIE_INTIE|EIE_PKTIE);
  // enable packet reception
  enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_RXEN);

}

void enc28j60PacketSend(unsigned int len, unsigned char* packet)
{
  // Set the write pointer to start of transmit buffer area
  enc28j60Write(EWRPTL, TXSTART_INIT);
  enc28j60Write(EWRPTH, TXSTART_INIT>>8);
  // Set the TXND pointer to correspond to the packet size given
  enc28j60Write(ETXNDL, (TXSTART_INIT+len));
  enc28j60Write(ETXNDH, (TXSTART_INIT+len)>>8);

  // write per-packet control byte
  enc28j60WriteOp(ENC28J60_WRITE_BUF_MEM, 0, 0x00);

  // copy the packet into the transmit buffer
  enc28j60WriteBuffer(len, packet);
  
  // send the contents of the transmit buffer onto the network
  enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_TXRTS);
}

unsigned int enc28j60PacketReceive(unsigned int maxlen, unsigned char* packet)
{
  u16 rxstat;
  u16 len;

  // check if a packet has been received and buffered
  if( !(enc28j60Read(EIR) & EIR_PKTIF) )
    return 0;
  
  // Make absolutely certain that any previous packet was discarded  
  //if( WasDiscarded == FALSE)
  //  MACDiscardRx();

  // Set the read pointer to the start of the received packet
  enc28j60Write(ERDPTL, (NextPacketPtr));
  enc28j60Write(ERDPTH, (NextPacketPtr)>>8);
  // read the next packet pointer
  NextPacketPtr  = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0);
  NextPacketPtr |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8;
  // read the packet length
  len  = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0);
  len |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8;
  // read the receive status
  rxstat  = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0);
  rxstat |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8;

  // limit retrieve length
  // (we reduce the MAC-reported length by 4 to remove the CRC)
  len = MIN(len, maxlen);

  // copy the packet from the receive buffer
  enc28j60ReadBuffer(len, packet);

  // Move the RX read pointer to the start of the next received packet
  // This frees the memory we just read out
  enc28j60Write(ERXRDPTL, (NextPacketPtr));
  enc28j60Write(ERXRDPTH, (NextPacketPtr)>>8);

  // decrement the packet counter indicate we are done with this packet
  enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON2, ECON2_PKTDEC);

  return len;
}

#include "stack.h"

/*NIC Einstellungen !! -----------------------------------
#########################################################*/

volatile unsigned char myip[4] = {192,168,178,3};
volatile unsigned char mymac[6] = {0xab,0xbc,0x6f,0x55,0x1c,0xc2};

/*#######################################################
# Funktion um die Checksumme zu berechnen, stammt     #
# ursprünglich von                    #
# Ulrich Radig :-),www.ulrichradig.de           #
# wer genaueres zur Checksummenbildung wissen möchte:  #
# http://www.netfor2.com/udpsum.htm            #
########################################################*/
int checksum (unsigned char * pointer,unsigned long result32,unsigned int result16)
{
  unsigned int result16_1 = 0x0000;
  unsigned char DataH;
  unsigned char DataL;
  
  //Jetzt werden alle Packete in einer While Schleife addiert
  while(result16 > 1)
    {
    //schreibt Inhalt Pointer nach DATAH danach inc Pointer
    DataH=*pointer++;

    //schreibt Inhalt Pointer nach DATAL danach inc Pointer
    DataL=*pointer++;

    //erzeugt Int aus Data L und Data H
    result16_1 = ((DataH << 8)+DataL);
    //Addiert packet mit vorherigen
    result32 = result32 + result16_1;
    //decrimiert Länge von TCP Headerschleife um 2
    result16 -=2;
    }

  //Ist der Wert result16 ungerade ist DataL = 0
  if(result16 > 0)
    {
    //schreibt Inhalt Pointer nach DATAH danach inc Pointer
    DataH=*pointer;
    //erzeugt Int aus Data L ist 0 (ist nicht in der Berechnung) und Data H
    result16_1 = (DataH << 8);
    //Addiert packet mit vorherigen
    result32 = result32 + result16_1;
    }
  
  //Komplementbildung (addiert Long INT_H Byte mit Long INT L Byte)
  result32 = ((result32 & 0x0000FFFF)+ ((result32 & 0xFFFF0000) >> 16));
  result32 = ((result32 & 0x0000FFFF)+ ((result32 & 0xFFFF0000) >> 16));  
  result16 =~(result32 & 0x0000FFFF);
  
return (result16);
}
/*  Funktionen, um zu überprüfen, ob das Packet für uns bestimmt ist, weitere Prüf'routinen'
  sind als Macros in stack.h definiert, da sie unabhängig von der IP immer auf dieselbe Art
  geprüft werden können
######################################################################################*/
uint8_t Checkmymac(void){
  if(buffer[0] == mymac[0] && buffer[1] == mymac[1] && buffer[2] == mymac[2] && buffer[3] == mymac[3] && buffer[4] == mymac[4] && buffer[5] == mymac[5])return(1);
  return(0);
}

uint8_t Checkmyip(void){
  if(buffer[38] == myip[0] && buffer[39] == myip[1] && buffer[40] == myip[2] && buffer[41] == myip[3])return(1);
  return(0);
}

/*Funktion um den Ethernet II Header zu erzeugen
####################################################################################*/
void eth(unsigned char *buff){
  
  for(unsigned char a=0; a<6; a++)
    {    
      buff[a] = buff[a+6];
      buff[a+6] = mymac[a];
    }
}
/*Funktion um den IP Header zu erzeugen
####################################################################################*/
void ip(unsigned char *buff){
  struct IP_header *ip;
  unsigned int sum;
  
  ip = (struct IP_Header *)&buff[24];

  for(unsigned char a=0;a<4; a++)
  {    
    ip->IP_destIp[a] = ip->IP_sourceIp[a];
    ip->IP_sourceIp[a] = myip[a];
  }


  ip->IP_checksum = 0x00; // checksum auf null setzen
  sum = checksum(&buff[14],0x00000000,20); // checksumme ausrechnen
  
  ip->IP_checksum = ((sum & 0xFF00) >> 8)|((sum & 0x00FF)<<8); 
}
/*Funktion um auf ein Arp Request eine Antwort zurück zu senden
####################################################################################*/
void arp(unsigned int len, unsigned char *buff){
    
  eth(buff); // ETHERNET II header erzeugen
  struct ARP_header *arp;
  arp = (struct ARP_Header *)&buff[21];
  arp->Opcode = 0x02; //Reply einstellen
  for(unsigned char a=0; a<6; a++)
    {      
      arp->ARP_destMac[a] = arp->ARP_sourceMac[a];
      arp->ARP_sourceMac[a] = mymac[a];
    }
  for(unsigned char a=0; a<4; a++)
    {    
      arp->ARP_destIp[a] = arp->ARP_sourceIp[a];
      arp->ARP_sourceIp[a] = myip[a];
    }
  
  
  enc28j60PacketSend(len-4,buff);  
}
/*Funktion um ICMP packete zu beantworten
####################################################################################*/
void icmp(unsigned int len, unsigned char *buff){
  eth(buff); // ETHERNET II header erzeugen
  ip(buff); // IP header erzeugen
  
  struct ICMP_header *icmp;
  icmp = (struct ICMP_Header *)&buff[34];
  
  icmp->ICMP_type = 0x00; // auf reply einstellen
  icmp->ICMP_code = 0x00; 
  
  //Simple ICMP Checksummenbildung, die Idee stammt von
  //Simon, siehe http://avr.auctionant.de/
  if(icmp->ICMP_checksumByteOne >  0xFF-0x08)icmp->ICMP_checksumByteTwo++;
  icmp->ICMP_checksumByteOne+=0x08; 
  
  enc28j60PacketSend(len-4,buff);  
}

/*UDP Funktion, beliebige Antwort
####################################################################################*/
void udp(unsigned int len, unsigned char *buff){ 
  uint16_t tempport,sum;
  struct UDP_header *udp;
  udp = (struct UDP_Header *)&buff[34];
  
  // ETHERNET II header erzeugen
  eth(buff); 
  
  // IP header erzeugen
  buff[16] = ((IP_UDP_HEADERLENGHT+len) & 0xFF00)>>8;
  buff[17] = ((IP_UDP_HEADERLENGHT+len) & 0x00FF); // ip header lenght anpassen
  
  ip(buff); 
    
  //An den Port zurücksenden, von dem das Packet gekommen ist
  tempport = udp->UDP_destPort; // Ziel Port zwischenspeichern
  udp->UDP_destPort = udp->UDP_sourcePort; //ZielPort neuschreiben
  udp->UDP_sourcePort = tempport; // SourcePort neuschreiben

  //Udp Header&Datenlänge schreiben
  udp->UDP_lenght_h = ((UDP_HEADERLENGHT+len) & 0xFF00)>>8;
  udp->UDP_lenght_l = ((UDP_HEADERLENGHT+len) & 0x00FF);
  
  //Checksumme ausrechnen...
  udp->UDP_checksum = 0x00;
  sum = checksum(&buff[26],TYPE_UDP+UDP_HEADERLENGHT+len,16+len); 
  udp->UDP_checksum = ((sum & 0xFF00) >> 8)|((sum & 0x00FF)<<8);
  
  //Und ab damit :-)
  enc28j60PacketSend(IP_UDP_HEADERLENGHT + ETH_HEADERLENGHT +len,buff);  
}

[zeigma (Gast)]

wer soll sich denn das alles durchlesen.. schreib mal ein Mini-Program, 
dass einfach immer nur sendet und miss nochmal. Hast Du SS als Ausgang 
definiert?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Wichtige Regeln - erst lesen, dann posten!
*    Längeren Sourcecode nicht im Text einfügen, sondern als 
Dateianhang*


Paul schrieb:
> dass ich an SCK keine Frequenz anliegen haben. Die Frage ist nur wieso.
Wie stellst du das fest?
Wann erwartest du da was?
Dort werden nur Takte ausgegeben, wenn passende Daten ausgegeben werden.
Siehst du an den Datenlaitungen was?

#define F_CPU          8000000                   /* Processor Speed */

Warum da andere ein UL hinter die F_CPU hängen ist dir bewusst?

[Werner (Gast)]

Wozu gibt es hier eigentlich soetwas wie Anhänge?

[holger (Gast)]

>ich bin gerade dabei einen Atmega16

Und wieso ist im Schaltplan dann ein ATMega8?