Ratselhaft mit JTAG

[Maxim B. (max182)]

Guten Tag,
heute macht meine Schaltung, was ich nicht verstehe. Genau:

AT Mega 324 PA. Über SPI sollten in MAX7219 jeweils 2 Bytes übertragen 
werden. Wie auch immer: ~CS, Addr, Data, CS.
Wenn ich schrittweise mit JTAG in AVR Studio 4.19 gehe, wird alles OK. 
Wenn ich versuche, Abschnitt schnell durch zu machen, bekommt MAX7219 
die Daten nicht.

Ich habe versucht, zwischen ~CS, Addr, Data und  CS Verzögerungen 
eizubauen - bringt nichts.

Wenn ich in Assembler Schritte gehe, dann funktioniert alles nur, wenn 
irgendwo (egal wo genau!) zwischen ~CS und CS ein Halt mit JTAG wird. 
Auf einem Stück bekommt MAX7219 nichts.

In der Schaltung stehen zwei MAX7219, mit beiden ist das Gleiche.

Es gibt keine Kurzschließungen. Abblockkondensatoren gint es mehr als 
genug.

Relevante Teil der Schaltung ist auf dem Bild. Zwei freie Ventile von 
HC132 werden benutzt, um SPI intern und extern sicher zu trennen (falls 
SPI extern mal in Slave-Modus läuft).

Was passiert bei dem Austausch mit JTAG, was auf SPI oder ~CS-Leitung 
wirken könnte? Weil Verhalten sich nur unterscheidet je nachdem 
dazwischen Austausch mit JTAG ist oder nicht.

Auch Testprogrammabschnitt:

const volatile __flash u8 barwert[13] = {0x00,0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,0xff,0xff,0xff,0xff};

#define MYDEL()    do{    asm volatile("nop");\
              asm volatile("nop");}while(0); 

void MYDEL_1(void){    
  asm volatile("nop");
} 

#define SEND(x,y)  do{    PORTC &= ~(1<<PC6);\
              MYDEL()\
              SPDR = x;\
              while(!(SPSR & (1<<SPIF)));\
              SPDR = y;\
              while(!(SPSR & (1<<SPIF)));\
              MYDEL_1();\
              PORTC |= (1<<PC6);\
              MYDEL();}while(0);

int main(void){ 

  spi_intern_init();

  spi_intern_outadr(BAR_ADR);

    // Dienstbyte

  SEND(0x0c,1);  // normal operation
  SEND(0x09,0x00);  // no decode
  SEND(0x0a,0x0f);  // max hell
  SEND(0x0b,7);  // scan limit
  SEND(0x0f,1);  // Test
  SEND(0x0f,0);  // no Test
  SEND(1,0);
  SEND(2,0);
  SEND(3,0);
  SEND(4,0);
  SEND(5,0);
  SEND(6,0);

while(1){ 

  for(u8 i=0;i<9;i++){

    SEND(1,barwert[i]);

    SEND(2,barwert[i+1]);

    SEND(3,barwert[i+2]);

    SEND(4,barwert[i+3]);

    SEND(5,barwert[i+4]);

  }
}
return 0;
}

Vielen Dank für eine Erklärung im voraus!

[Jim M. (turboj)]

SPDR wird nicht gelesen. Dadurch wird SPIF ebenfalls nicht gelöscht 
IMHO, der Code rennt durch den SPI Teil ohne Bremse durch.

Abhilfe: Jeweils ein Dummy read auf SPDR nach dem Warten aufs SPIF.

[Maxim B. (max182)]

Ach so!!!
Das war meine Dummheit: ich wollte 2 bytes Code sparen :)

[Maxim B. (max182)]

Half leider nicht...
Jetzt sieht die Funktion so aus:

// spi.h
static inline u8 spi_master_transmit(u8 data)
{
  /* Start transmission */
  SPDR = data;
  /* Wait for transmission complete */
  while(!(SPSR & (1<<SPIF)));
  return SPDR;
} 

static inline void spi_write_2byte(volatile u8 *csreg, u8 csbit, u8 data0, u8 data1)
 
{  
  *csreg &= ~(1<<csbit);
  spi_master_transmit(data0);
  spi_master_transmit(data1);
  *csreg |= (1<<csbit);  
}

// spi_intern.h
static inline void spi_intern_write_2byte(u8 data0, u8 data1)
 
{  
  spi_write_2byte(&SPI_INTERN_E_PORT,SPI_INTERN_E,data0,data1);  
}

// main.c
spi_intern_write_2byte(0x0c,1);  // normal operation
...

Effekt bleibt, leider

[Maxim B. (max182)]

Das Problem habe ich gelöst: es half Oszilloskop.
MOSI ist mit Widerstand 47k an Vcc angeschlossen (um in dem hochohmigen 
Zustand Stromverbrauch zu reduzieren).
Mit Programm-SPI ist es gelungen, normale Datenübertragung auf etwa 20 
kHz zu schaffen. Oszilloskop zeigt langsame steigende SIgnalflanke. JTAG 
zeigt DDR-bit = 1.

Also, defekte Mikrocontroller. P-Transistor sollte kaputt sein.