Atmega8 + Atmega644p über TWI Problem

[Philipp M. (lord-maricek)]

Moin,

ich möchte einen Mega8 und einen Mega644p über I2C kommunizieren lassen, 
bzw. den Mega644p (als Master) nur vom Mega8 lesen lassen. SCL + SDA ist 
richtig verbunden, und da beide über eine Spannungsversorgung laufen, 
ist Masse auch verbunden.

Auf dem Mega644p läuft die Master Lib von Peter Fleury.
Auf dem Mega8 läuft die Slave Lib von hier:
Beitrag "AVR TWI Master und Slave Funtionen in C"

Als Test requestet der Mega644p 3 Bytes vom Mega8. Wenn ich beide 
gleichzeitig neu starte, gibt der 644p die 3 Bytes auch über USART aus. 
Nach einem Delay von 500ms, startet der 644p die Verbindung wieder aber 
kann nichts mehr empfangen und der Watchdog startet nach 2sek den 
Mega644p neu.
Das ist das erste Problem, dass er nur einmal empfangen kann, und danach 
nicht mehr.

Ein anderes Problem ist, dass nach dem WDT Reset, der WDT irgentwo 
hängenbleibt, denn den TWI Bus öffnet er nicht mehr, startet aber nach 2 
Sek trotzdem neu, obwohl in der while Schleife nur das delay von 500ms 
ist.

Hier sind die codes:
Atmega8 (16Mhz):

#define F_CPU 16000000UL
#define OWN_ADRESS 0x8A

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include "PPM.h"
#include "TWI_Slave.h"

void delay_ms(unsigned long t)
{
  for(unsigned long i=0;i<t;i++)
  {
    _delay_ms(1);
  }
}

int main(void)
{
  delay_ms(50);
  DDRD |= (1<<DDD2);
  delay = 1000;
  
  ppm_Init();
  TWIS_Init(OWN_ADRESS,400000);  //Hier wird auch das TWIE Bit gesetzt für                 //das Interrupt
  
  sei();
  
  
  while (1)
    {

    

    }
  return 0;   
}

ISR(TWI_vect)
{
  uint8_t TWIS_ResonseType;
  if (TWIS_ResonseRequired (&TWIS_ResonseType))
  {
    switch (TWIS_ResonseType)
    {
      case TWIS_ReadBytes:
        TWIS_Stop ();
        break;
      case TWIS_WriteBytes:
        TWIS_Write('H');
        TWIS_Write('A');
        TWIS_Write('L');
        TWIS_Stop ();
        break;
    }
  }  
}

Atmega644p(18.432Mhz)

#include "define.h"
#include "types.h"
#include "global.h"

#include "M_AVR_PROC/M_AVR_PROC.h"
#include "M_STEER_MANAGEMENT/M_STEER_MANAGEMENT.h"
#include "M_ROUTE_MANAGEMENT/M_ROUTE_MANAGEMENT.h"
#include "M_LSM303DLH/M_LSM_303DLH.h"
#include "M_GPS/M_GPS.h"
#include "M_PROTOCOL/M_PROTOCOL.h"
#include "M_PROTOCOL/fifo.h"

#include <avr/io.h>
#include <stdlib.h>
#include <stdio.h>
#include <avr/wdt.h>


//WDT
uint8_t mcusr_mirror __attribute__ ((section (".noinit")));

void get_mcusr(void) __attribute__((naked)) __attribute__((section(".init1")));
void get_mcusr(void)
{
    mcusr_mirror = MCUSR;

    // disable the dog
    MCUSR = 0;
    wdt_disable();
}


//FIFO
fifo_t fifo_pc_in;
fifo_t fifo_pc_out;
fifo_t fifo_gps;
uint8_t fifo_buffer_in[60];
uint8_t fifo_buffer_out[60];
uint8_t fifo_buffer_gps[60];

//Timeouts
#define TIMEOUT_GPS 1000
#define TIMEOUT_WI232 1000
#define TIMEOUT_COMPASS 500
#define TIMEOUT_HEARTBEAT 500
#define TIMEOUT_PPM 100
#define TIMEOUT_GPS_MSG 2500
#define TIMEOUT_ALTERNATE_HOMING 10000

//Timer Hardware
unsigned long timer_gps_lc;
unsigned long timer_wi232_lc;
unsigned long timer_compass_lc;

//Timer Software
unsigned long timer_heartbeat_lc;
unsigned long timer_ppm_lc;
unsigned long timer_gps_msg;
unsigned long timer_alternate_homing;

//Checks Send
uint8_t timer_wi232_lc_send_check;

int main(void)
{
    fifo_init(&fifo_pc_in,fifo_buffer_in,60);
    fifo_init(&fifo_pc_out,fifo_buffer_out,60);
    fifo_init(&fifo_gps,fifo_buffer_gps,60);

    //Timer
    timer_gps_lc = 0;
    timer_wi232_lc = 0;
    timer_compass_lc = 0;
    timer_heartbeat_lc = 0;
    timer_ppm_lc = 250;
    timer_wi232_lc_send_check = 0x00;

    M_AVR_PROC_INIT();
    PORTB |= LED_RED|LED_GREEN;
delay_ms(20);

    PORTB &= ~ LED_GREEN;
PORTB &= ~ LED_RED;
    PORTB &= ~ LED_GREEN;

    sei();

    if( mcusr_mirror &(1<<WDRF))
    {
        char a[10];
        uint8_t e = protocol_msg_code(PROTOCOL_RESET,PROTOCOL_WATCHDOG_RESET,a);
        for(uint8_t i=0; i<e; i++)
        {
            fifo_put(&fifo_pc_out,a[i]);
        }
        UCSR0B |= (1<<UDRIE0);
        //PORTB |= LED_RED;
    }
    else
    {
        char a[10];
        uint8_t e = protocol_msg_code(PROTOCOL_RESET,PROTOCOL_NORMAL_RESET,a);
        for(uint8_t i=0; i<e; i++)
        {
            fifo_put(&fifo_pc_out,a[i]);
        }
        UCSR0B |= (1<<UDRIE0);
        //PORTB |= LED_GREEN;
    }

    PORTB &= ~ LED_RED;
    PORTB &= ~ LED_GREEN;

    wdt_enable(WDTO_2S);
while(1)
  {
    wdt_reset();
    delay_ms(500);
    wdt_reset();
    if(i2c_start(PPM_DECODER+1)==0)
    {
      fifo_put(&fifo_pc_out,'Z');
      UCSR0B |= (1<<UDRIE0);
      uint8_t a = i2c_readAck();
      uint8_t b = i2c_readAck();
      uint8_t c = i2c_readNak();
      fifo_put(&fifo_pc_out,a);
      fifo_put(&fifo_pc_out,b);
      fifo_put(&fifo_pc_out,c);
      fifo_put(&fifo_pc_out,'\n');
      UCSR0B |= (1<<UDRIE0);
    }
    i2c_stop();
    
  }

ISR(USART0_UDRE_vect)
{
    int a = fifo_get_nowait(&fifo_pc_out);
    if(a==-1)
    {
        UCSR0B &= ~(1<<UDRIE0);
        return;
    }
    else
    {
        UDR0 = a;
    }
}

ISR(USART0_RX_vect)
{
    uint8_t a = UDR0;
    fifo_put(&fifo_pc_in,a);
}

ISR(USART1_RX_vect)
{
    uint8_t a = UDR1;
    fifo_put(&fifo_gps,a);
}

ISR(WDT_vect)
{

}

Ich hab in dem letzteren code eine riesige "Initialisierung-Orgie" 
rausgelassen, weil da nur Software Funktionen mit tonnenweise Zeigern 
Initialisiert werden, die aber mit dem momentanen Tets nichts zu tun 
haben.

Wer was zum Compilieren will, ich hab beide codes angehängt.

Ich hoffe jemand kann mir helfen.

MfG
Philipp

P.S.: Wie is das eig mit der Reihenfolge, wenn der Master Neustartet, 
müssen die Slaves auch neustarten? Muss der Master zuerst Initialisiert 
werden oder können auch die Slaves voher Initialisiert werden?

[Philipp M. (lord-maricek)]

Hat niemand eine Idee woran es liegen könnte? Mit dem Kompass am I2C Bus 
kann ich noch kommunizieren, aber warum sendent der Mega8 nach dem 
ersten mal nichts mehr?

MfG
Philipp