Danke für die schnelle antwort.

Den code kenne ich, aber läuft nicht auf den AtTiny13 weil er HW-SPI ist.

>>Es ist schwer Deinem Code etwas zu entlocken
klar sehe ich gerade auch. der code ist aus einer SW-SPI-Master code um ein AVR mit 2 MAX3100 als SPI-UART-brigde.
QUELLE: http://www.mikrocontroller.net/attac...dual_rs485.pdf

>> Du alle nötigen includes?
denke ich mal. habe zurzeit eine 1 IO.h werde später Interrupt.h noch ein binden als Taktgeber für CLK ex.INT0.

die main ist noch nicht fertig. Ich beschreibe mal was gemacht werden soll dann versteht man den code besser (hoffe ich)
der Tiny13 soll adc werte als slave an Attiny2313(Master) per spi schicken (AVR-CDC-SPI) und ma PC-terminal ausgeben.
So dachte ich mir wie SPI-Slave funktioniert SS schaltet Low. Tiny13 weiss es wird gesendet und schiebt immer ein Bit raus wenn CLK high wird. Bis alle Bits gesendet sind.
Die Schatung für den tiny2313 läuft und kann per command SS0 und SS1, High bzw Low geschalten werden.

Der Code für Tiny13
Code:
#include <avr/io.h>     // Namen der IO Register
#include "adc-init.h"
#include "SPI-init.h"

unsigned int SPI_Write_Word(unsigned int word)
{
uint16_t MSB = 0b100000000000000; // Letzte bit
uint16_t temp = 0;
//CLK gibt den takt/übertagungsgeschwindigkeit vor MISO und MOSI halten sich daran

	
	if(SPI_CLK_PB2 & (1<<SPI_CLK_PB2)) //wen sck auf High wird 1 bit gesende
	{
		if(MSB & word)SPI_MISO_PORT |= (1<<SPI_MISO_PB3); //Pin Miso high
		else SPI_MISO_PORT &= ~(1<<SPI_MISO_PB3);
		MSB <<=1;			//MSB First
	
	}
	
	else //wenn clk low ist nichts machen

return (temp);	
}

int main(void)
{    		
  uint16_t adcval;
  ADC_Init();

  while( 1 ) {
    adcval = ADC_Read(3);  // Kanal 0
    // mach was mit adcval
 
    adcval = ADC_Read_Avg(2, 4);  // Kanal 2, Mittelwert aus 4 Messungen
    // mach was mit adcval
  

      if(!(SPI_SS_PB1 & (1<<SPI_SS_PB1)))	// Wenn SS(PB1) auf low geht start der Übertragung  
	  {   
          SPI_Write_Word(adcval); 	//
      }
      else
	  {
        
      }
	  }
   return 0;
}
Mit dem code ADC-Init lief eigendlich ohne probleme auf mega8 habe die register für tiny13 angepasst

Code:
/* ADC initialisieren */
void ADC_Init(void) {
 
  uint16_t result;
 
//  ADMUX = (0<<REFS1) | (1<<REFS0);      // AVcc als Referenz benutzen
  ADMUX =  (1<<REFS0)|(1<<MUX1)|(1<<MUX0);      // interne Referenzspannung nutzen
  // Bit ADFR ("free running") in ADCSRA steht beim Einschalten
  // schon auf 0, also single conversion
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
 
  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
 
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 
  while (ADCSRA & (1<<ADSC) ) {}        // auf Abschluss der Konvertierung warten
  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
     Wandlung nicht übernommen. */
  result = ADCW;
}
 
/* ADC Einzelmessung */
uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x0F)) | (channel & 0x0F); //ADC3 ist PB3
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung warten
  return ADCW;                    // ADC auslesen und zurückgeben
}
 
/* ADC Mehrfachmessung mit Mittelwertbbildung */
uint16_t ADC_Read_Avg( uint8_t channel, uint8_t average )
{
  uint32_t result = 0;
 
  for (uint8_t i = 0; i < average; ++i )
    result += ADC_Read( channel );
 
  return (uint16_t)( result / average );
}
Der Spi-init ist nur die PORT deklaration
Code:
 //DDRB
#define SPI_MOSI_DDR  DDRB
#define SPI_CLK_DDR   DDRB
#define SPI_MISO_DDR  DDRB
#define SPI_SS_DDR    DDRB

//PORTB
#define SPI_MOSI_PORT  PORTB
#define SPI_CLK_PORT   PORTB
#define SPI_MISO_PORT  PORTB
#define SPI_SS_PORT    PORTB

// PIN 
#define SPI_MOSI_PB0  PB0
#define SPI_SS_PB1    PB1
#define SPI_CLK_PB2   PB2
#define SPI_MISO_PB3  PB3



//Slave-deklaration
void SPI_INIT(void)
{
// MOSI, CLK und SS auf Eingang setzen
  SPI_MOSI_DDR = (1<<SPI_MOSI_PB0);
  SPI_CLK_DDR  = (1<<SPI_CLK_PB2);
  SPI_SS_DDR   = (1<<SPI_SS_PB1);
// MOSI, CLK und SS Internen Pull-Up aktivieren 
  SPI_MOSI_PORT |=(1<<SPI_MOSI_PB0);
  SPI_CLK_PORT  |=(1<<SPI_CLK_PB2);
  SPI_SS_PORT   |=(1<<SPI_SS_PB1);
// MISO auf Ausgang setzen 
  SPI_MISO_DDR |= (1<<SPI_MISO_PB3);
//MISO auf High setzten
  SPI_MISO_PORT |= (1<<SPI_MISO_PB3);
}
hoffe Ihr erschlägt mich nicht für den langen Post bzw. schreckt nicht ab