ATmega > DAC (SPI Problem)

[rrobert]

Seid gegrüßt,

im Rahmen eines Projektes beschäftige ich mich derzeit mit der
Ansteuerung eines AD5624R mit Hilfe eines ATmega168 über die SPI
Schnittstelle.

An sich soll das Ganze ja sehr einfach gehen mit SPI, jedoch beiße ich
mir derzeit einwenig die Zähne daran aus.

Die Signale auf den SPI bekomme ich schon (mittels Oszi überprüft), aber
eine Reaktion seitens des DAC bleibt leider aus.

Die beiden Bilder zeigen das Oszibild für eine SPI Übertragung. Einmal
CLK+Data und einmal SS+Data.

Hier nun vllt die Codeschnipsel, die jeden interessieren sollten:

void PORTS_init() 
{
  DDRB |= (1<<PB2)|(1<<PB3)|(1<<PB5);      // LED , SPI::MOSI/CLK
  DDRC |= (1<<PC1)|(1<<PC2)|(1<<PC3)|(1<<PC4);  // SPI::SS1...4 outputs
  PORTC |= (1<<PC1)|(1<<PC2)|(1<<PC3)|(1<<PC4);  // all high
}

void SPI_MasterInit(void) 
{
  SPCR |= (1<<SPE) | (1<<MSTR) | (1<<SPR1) | (1<<SPR0) | (0<<CPOL) | (0<<DORD) | (1<<CPHA);
}

void SPI_Master_to_DAC_send(uint8_t mode, uint8_t dac, uint16_t wert) 
{
  uint8_t byte0 = 0x0;
  uint8_t byte1 = 0x0;
  uint8_t byte2 = 0x0;
 
  switch( mode ) 
  {               
    case 0: byte0 |= 0x0; break;  // write to input register n
    case 1: byte0 |= 0x8; break;  // update dac register n  
    case 2: byte0 |= 0x10; break;  // write to input register n, update all
    case 3: byte0 |= 0x18; break;  // write to and update dac channel n
  }
  switch( dac ) 
  {                 
    case 0: byte0 |= 0x0; break;  // DAC A
    case 1: byte0 |= 0x1; break;  // DAC B
    case 2: byte0 |= 0x2; break;  // DAC C
    case 3: byte0 |= 0x3; break;  // DAC D
    case 4: byte0 |= 0x7; break;  // ALL DAC    
  }

  byte1 = (wert>>4);
  byte2 = (wert<<4);

  PORTC &= ~(1<<PC4);
  SPI_MasterSend( byte0, byte1, byte2 );
  _delay_us(5);
  PORTC |= (1<<PC4);
}

void SPI_MasterSend(char cData0, char cData1, char cData2) 
{  
  cli();
  SPDR = (uint8_t)cData0; 
  while(!(SPSR & (1<<SPIF)));
  SPDR = (uint8_t)cData1; 
  while(!(SPSR & (1<<SPIF)));
  SPDR = (uint8_t)cData2; 
  while(!(SPSR & (1<<SPIF)));
  sei();
}

Initialisieren tu ich den DAC mit einem kompletten Reset, einschalten
der internen Referenz sowie setzen des LDAC für alle Outputs auf 1.

Sende ich nun ein SPI_Master_to_DAC_send() mit einem Wert, so passiert
nichts. Habe nun schon alle Modi durchprobiert.

Kann mir jemanden eine Hilfestellung liefern?

Beste Grüße,
Robert

[wkrug]

Hast Du schon mal nachgeguckt ob Deine Clock Polarity Clock Phase und Data Order einstellungen für den AD5624 Chip passen?
Hast Du in deiner Routine das /SS Signal per Software! bedient ( Bei der Einstellung als Master muss das per Software erledigt werden ) .
Wenn ich probleme mit der SPI hab, dann schreib ich mal schnell de software SPI routine - ist ja nicht besonders schwierig.
Wenn Die dann geht, dann weiß ich zumindest, das es von der Hardware her passt und der Fehler nur noch bei den Einstellwerten für die SPI liegen kann.
Dann kann man mit den Parametern der SPI noch mal rumspielen und kriegt es dann meistens auch hin.
Manche Chips lassen sich überhaupt nicht per Hardware SPI ansprechen, z.B. wenn Sie eine vom 8 Bit Raster ( also 8, 16, 24, 32Bit ) abweichende Bitbreite am SPI Bus haben ( ja es gibt so was! ).
Wenn man mal die richtigen einstellungen für die SPI gefunden hat, funktioniert es in der Regel problemlos.

[rrobert]

Ich bin mittlerweile der Meinung so ziemlich jede Einstellung ausprobiert zu haben, jedoch ohne Erfolg.

Welche SPI Einstellung würdest du Anhand des Datasheet des AD5624 denn wählen? (Das Datasheet habe ich der Modellbezeichnung angehängt (einfach auf den Link klicken)

Und zum /SS. Den habe ich standardmäßig als Output definiert und dann zusätzlich vor jeder Übertragung noch auf high gesetzt (was laut Datasheet des ATmega168 aber nicht nötig sein soll, da es keine Auswirkung haben soll, wenn der SS/ als Output definiert ist). An dem SS/ Pin des ATmega168 ist bei meinem Crumb128 auch eine LED angeschlossen, die leuchtet, wenn in den Pin auf 0 setze,

[BASTIUniversal]

Hallo rrobert,

im Prinzip schaut die Ansteuerung des "SYNC" Pins gut aus. Er muss auf Low gezogen werden, bevor die Ausgabe an "SCLK" beginnt und dann erst nach dem letzten Clock-Impuls wieder auf High gebracht werden.
Es kann sein, dass die Zeit zwischen dem Wechsel an SYNC und dem ersten Clock-Impuls zu kurz ist. Wobei die min. Zeit mit 13ns angegeben ist und der Fall daher unwahrscheinlich.

Ich mache bei der SPI-Kommunikation immer erst einen Versuch über eine Software-SPI bevor ich auf Hardware-SPI umsteige. Das hat den Vorteil, dass du alle Pins so wackeln kannst, wie im Datenblatt vorgegeben. Die Verwirrung mit CPOL usw. kann man so erstmal umgehen und weiß, dass der Chip und Kommunikation funktioniert.

Gruß
Basti

[rrobert]

Wie genau erziele ich mit dem Software SPI eine Vorteil gegenüber dem Hardware SPI? Hast du vllt einen Link zu einem Software SPI?

Zu den Timings. Der ganze uC läuft bei 8MHz und die SPI Clock Rate ist bei fck/128. Also wirklich das Langsamste, was irgendwie möglich ist (hatte die Überlegung, dass so vllt die wenigsten Probleme auftreten).

[021aet04]

Wie sieht die Schaltung aus? Hast du die Referenz angeschlossen bzw kannst du da eine Spannug messen? Eventuell hast du keine Verbindung (vergessen bzw kalte Lötstelle,...)

MfG Hannes

[rrobert]

Ich habe keine Referenz angeschlossen. Habe diese jedoch in der Initialisierung auf "Intern ON" gestellt und kann sie messen (2,48V).

[rrobert]

Wie schaut es mit der Übertragung der einzelnen Byte des 24bit Wortes aus? Wie verhält sich so ein Shiftregister da? Ich sende ja das erste Byte, dann das Zweite, dann das Dritte. Jeweils mit dem MSB "links".

Derzeit versende ich ja das Paket mit dem MSB first und das Byte_high zuerst. Das könnte mit dem Datenblattinfos kollidieren, oder?

[021aet04]

Du hast zwar das falsche DB vom DAC gepostet, habe aber das richtige schon gefunden. Du hast das DB vom AD5624 nicht vom 5624R gepostet.

Ich habe im DB vom Atmega geschaut. Laut diesem DB steht das CPHA Bit für die Phase der Clockimpulse (Rising oder Falling Edge). Du hast dieses Bit auf 1 gestellt, laut DB ist das für rising edge. Beim DAC steht aber drinnen das die Daten bei falling edge übernommen werden. Versuche einmal in der Init Routine das CPHA auf 0 zu schalten (bzw lassen).

Hier ist das richtige DB vom DAC http://www.analog.com/static/importe...644R_5664R.pdf

MfG Hannes

[rrobert]

Okay. Das habe ich nun versucht.

Mein SPI schaut wie folgt aus:

void SPI_MasterInit(void) {
	// Set /SS, MOSI and SCK output, all others input 
	DDRB = (1<<PB2)|(1<<PB3)|(1<<PB5);				// SS, MOSI, CLK are Outputs
	//PORTB &= ~(1<<PB2);								// LED on (PB2 low)
	
	DDRC = (1<<PC1)|(1<<PC2)|(1<<PC3)|(1<<PC4);		// SPI::SS1...4 outputs
	PORTC = (1<<PC1)|(1<<PC2)|(1<<PC3)|(1<<PC4);	// all high
	// Enable SPI, Master, MSB first, SPI Mode 1, set clock rate fck/128
	SPCR |= (1<<SPE) | SPI_MSB_1 | (1<<MSTR) | SPI_MODE_0 | SPI_SPEED_128;
}

void SPI_MasterSend(char high, char mid, char low) {
	
	PORTB |= (1<<PB2);				// SS is set high, effects that LED is off				
	cli();
	_delay_us(5);
	SPDR = high; 
	while(!(SPSR & (1<<SPIF)));
	SPDR = mid; 
	while(!(SPSR & (1<<SPIF)));
	SPDR = low; 
	while(!(SPSR & (1<<SPIF)));
	_delay_us(5);
	sei();
	PORTB &= ~(1<<PB2);				// SS is set low, effects that LED is on
}

void SPI_Master_to_DAC_send(uint8_t mode, uint8_t dac, uint16_t wert) {
	
	uint8_t byte_high = 0x0;
	uint8_t byte_mid = 0x0;
	uint8_t byte_low = 0x0;
	char dac_buf[128];					// Buffer für Konsolenausgabe-String

	switch( mode ) 
	{ 							
		case 0: byte_high |= 0x0; break;	// write to input register n
		case 1: byte_high |= 0x8; break;	// update dac register n	
		case 2: byte_high |= 0x10; break;	// write to input register n, update all
		case 3: byte_high |= 0x18; break;	// write to and update dac channel n
	}
	switch( dac ) 
	{ 								
		case 0: byte_high |= DAC_A; break;
		case 1: byte_high |= DAC_B; break;
		case 2: byte_high |= DAC_C; break;
		case 3: byte_high |= DAC_D; break;
		case 4: byte_high |= DAC_ALL; break;
	}

	byte_mid = (wert>>4);
	byte_low = (wert<<4);

	PORTC &= ~(1<<PC1);
	SPI_MasterSend( byte_high, byte_mid, byte_low );
	PORTC |= (1<<PC1);
	sprintf( dac_buf, "## SYSTEM ## DAC Data send (%d)(%d[%d][%d])\n\r", byte_high,wert,byte_mid,byte_low);
	UART_puts(dac_buf);
}

#define SPI_MODE_0		( (0<<CPOL) | (0<<CPHA) )
#define SPI_MODE_1		( (0<<CPOL) | (1<<CPHA) )
#define SPI_MODE_2		( (1<<CPOL) | (0<<CPHA) )
#define SPI_MODE_3		( (1<<CPOL) | (1<<CPHA) )
#define SPI_MSB_1		( (0<<DORD) )
#define SPI_LSB_1		( (1<<DORD) )
#define SPI_SPEED_64	( (1<<SPR1) | (0<<SPR0) )
#define SPI_SPEED_128	( (1<<SPR1) | (1<<SPR0) )