AD5292 mit SPI des ATmega32 ansteuern

[Cheng L. (cheng_l)]

Hallo,

Für ein Projekt muss ich über einen digitalen Potentiometer AD5292 
mittels eines ATmega32 ansteuern. Der ATmega32 beherrscht ja SPI, also 
sollte das theoretisch möglich sein. Nur ich bekomme es einfach nicht 
hin.

Zu meiner Entwicklungsumgebung für den ATmega32 gehört das Atmel 
Evaluluationsboard V2.0.1. Dabei habe ich an dem Board alles unverändert 
gelassen (auch Jumper drin gelassen), sodass ich die Ausgänge über JP4 
rausführe. Programmieren tue ich mit Atmel Studio 6 sowie einen 
ISP-Programmer mit STK500.

Die Entwicklungsumgebung funktioniert auch soweit, da ich dies schon mit 
anderen Projekten erfolgreich getestet habe. Mir macht einfach die 
Ansteuerung des AD5292 Kopfzerbrechen. Im Netz habe ich auch speziell zu 
dieser Konfiguration nichts gefunden.

Mein Code sieht folgendermaßen aus:

#include <avr/io.h>

#define DDR_SPI      DDRB
#define DD_MOSI      DDB5
#define DD_SCK      DDB7
#define DD_SS      DDB4

void SPI_INIT (void)
{
  DDR_SPI |= (1<<DD_MOSI) | (1<<DD_SCK) | (1<<DD_SS);       // Set MOSI , SCK , and SS output
  SPCR = ( (1<<SPE)|(1<<MSTR) | (1<<SPR1) |(1<<SPR0));  // Enable SPI, Master, set clock rate fck/128
}

void SPI_DATA (char data)
{
  SPDR = data;                                                         // Send data
  while(!(SPSR & (1<<SPIF))){;                                         // Wait
    
  }
}

int main(void)
{
  
  SPI_INIT();
  PORTB = PORTB & 0b11101111;      // SS low
  SPI_DATA (0b00011000);             // Command #6
  SPI_DATA (0b00000011);
  SPI_DATA (0b00000110);           // Command #1
  SPI_DATA (0b00000000);
  PORTB = PORTB | 0b00010000;     // SS high
  
    while(1)
    {

    }
}

Also über SS, MOSI und SCK werden auf jeden Fall Signale rausgesendet. 
Nur am Widerstand des Potentiometers ändert sich nichts. Eigentlich 
müsste ich auch alles richtig verdrahtet haben.

Da ich das Projekt recht zügig fertigkriegen muss, wäre ich über jede 
erdenkliche Hilfestellung sehr dankbar. Eventuell haben auch andere 
Leute dasselbe Problem.

Vielen Dank im Vorraus!

Mit freundlichen Grüßen,

Cheng L.

[guest111 (Gast)]

Hey,

schon Mal probiert die <spi.h> einzubinden?
Dann würde ich gern wissen wollen, woher du weißt, dass auch die 
richtigen Bits zur richtigen Zeit ankommen? Hast du ein Oszi da?
Lad´ mal bitte der Einfachheit halber den Schaltplan µC-DigPoti hoch.


MfG
guest111

[Cheng L. (cheng_l)]

Hallo,

Danke für deine hilfreiche Antwort!

Ich habe den Teil µC-DigPoti als Bild hochgeladen. Im Schaltplan steht 
noch Mega8, weil ich das später mal verwenden möchte. Eigentlich sollte 
ja richtig angeschlossen sein:

PB2 (SS) --> SYNC
PB4 (MISO) --> DIN
PB (SCK) --> SCLK

Ich werde das mal mit der <spi.h> ausprobieren.

Ansonsten weiss ich, dass ISP und SPI sich behindern, jedoch habe ich 
zuerst das DigiPoti nicht angeschlossen, um per ISP das Programm in den 
µC zu laden. Anschließend erst die SPI Pins belegt.

Gibt es zu dieser Konfiguration irgendwelche fertigen Code Beispiele?

Auf weitere hilfreiche Antworten würde ich mich sehr freuen.

Viele Grüße,

Cheng L.

[Oliver R. (orb)]

Cheng L. schrieb:
> Ansonsten weiss ich, dass ISP und SPI sich behindern,

Dann hast Du da noch einen Fehler. ISP ist nur aktiv wenn Reset low ist. 
dann sollte der AD5292 hochohmig auf dem SPI sein, dessen Reset auch low 
sollte helfen.

[Cheng L. (cheng_l)]

Danke für deinen Tipp.
Du meinst also, ich sollte den Reset des AD5292 auch mit den µC 
verbinden und diesen auf low setzen, wenn das Programm schon per ISP auf 
den µC geladen ist?

[Cheng L. (cheng_l)]

Also ich habe es mit spi.h und Reset des AD5292 auf low versucht. Leider 
klappt das immer noch nicht.

Hier der Code für spi.h, was ich gefunden habe:

#ifndef _SPI_H_
#define _SPI_H_

#include <avr/io.h>


extern void spi_init();
extern void spi_transfer_sync (uint8_t * dataout, uint8_t * datain, uint8_t len);
extern void spi_transmit_sync (uint8_t * dataout, uint8_t len);
extern uint8_t spi_fast_shift (uint8_t data);


#endif /* _SPI_H_ */

Und hier nun mein neues Programm:

#include <avr/io.h>
#include "spi.h"
#include <avr/interrupt.h>

#define PORT_SPI    PORTB
#define DDR_SPI     DDRB
#define DD_MISO     DDB6
#define DD_MOSI     DDB5
#define DD_SS       DDB4
#define DD_SCK      DDB7

void spi_init()
// Initialize pins for spi communication
{
  DDR_SPI &= ~((1<<DD_MOSI)|(1<<DD_MISO)|(1<<DD_SS)|(1<<DD_SCK));
  // Define the following pins as output
  DDR_SPI |= ((1<<DD_MOSI)|(1<<DD_SS)|(1<<DD_SCK));

  SPCR = ((1<<SPE)|               // SPI Enable
          (0<<SPIE)|              // SPI Interupt Enable
          (0<<DORD)|              // Data Order (0:MSB first / 1:LSB first)
          (1<<MSTR)|              // Master/Slave select
          (0<<SPR1)|(1<<SPR0)|    // SPI Clock Rate
          (0<<CPOL)|              // Clock Polarity (0:SCK low / 1:SCK hi when idle)
          (0<<CPHA));             // Clock Phase (0:leading / 1:trailing edge sampling)

  SPSR = (1<<SPI2X);              // Double Clock Rate
}
 
void spi_transfer_sync (uint8_t * dataout, uint8_t * datain, uint8_t len)
// Shift full array through target device
{
  uint8_t i;
  for (i = 0; i < len; i++) {
    SPDR = dataout[i];
    while((SPSR & (1<<SPIF))==0);
    datain[i] = SPDR;
  }
}
 
void spi_transmit_sync (uint8_t * dataout, uint8_t len)
// Shift full array to target device without receiving any byte
{
  uint8_t i;
  for (i = 0; i < len; i++) {
    SPDR = dataout[i];
    while((SPSR & (1<<SPIF))==0);
  }
}

uint8_t spi_fast_shift (uint8_t data)
// Clocks only one byte to target device and returns the received one
{
  SPDR = data;
  while((SPSR & (1<<SPIF))==0);
  return SPDR;
}

int main(void)
{
  
  // Allocate buffer array
  uint8_t data_buf[1];
  // Initialize SPI
  spi_init();
  // SS low
  PORTB = PORTB & 0b11101111;
  
  // Command #6
  data_buf[0] = 0b00011000;
  spi_transmit_sync(data_buf,1);
  data_buf[0] = 0b00000011;
  spi_transmit_sync(data_buf,1);
  
  // Command #1
  data_buf[0] = 0b00000110;
  spi_transmit_sync(data_buf,1);
  data_buf[0] = 0b00000000;
  spi_transmit_sync(data_buf,1);
  
  // SS high  
  PORTB = PORTB | 0b00010000;
}

Was mache ich bloss falsch?

[guest111 (Gast)]

Also deine Schaltung kann man ja echt vergessen. Dort kann ich nix 
erkennen, weil A) alle Leiterzüge kreuz und quer gehen
und  B) nur ein Teil der Schaltung zu erkennen ist.

Nichtsdestotrotz...warum übergibst du der Funktion spi_transmit_sync() 
denn die Datenlänge 1Bit?? Du willst doch 1Byte haben also 8Bit.
Schau dir bitte noch mal genau Seite 9 und Seite 22 an. Auf Seite 9 ist 
auch ein schönes Beispiel, wie man Daten schreibt (Figure 3). Dazu musst 
du das RESET Pin eigentlich nicht beachten, weil das nur für das Löschen 
des RDAC Registers genutzt wird. Aber du kannst es auch einfach 
überschreiben.
Ach...und wenn du den Widerstand des Potis ändern möchtest, musst du 
nach Zeile 2 der Tabelle 11 auf Seite 22 vorgehen.

Nur so nebenbei PORTB = PORTB & 11... ist vom Stil her Quatsch. Eher 
PORTB=11...

MfG
guest111

[Cheng L. (cheng_l)]

guest111 schrieb:
> Also deine Schaltung kann man ja echt vergessen. Dort kann ich nix
> erkennen, weil A) alle Leiterzüge kreuz und quer gehen
> und  B) nur ein Teil der Schaltung zu erkennen ist.
>
> Nichtsdestotrotz...warum übergibst du der Funktion spi_transmit_sync()
> denn die Datenlänge 1Bit?? Du willst doch 1Byte haben also 8Bit.
> Schau dir bitte noch mal genau Seite 9 und Seite 22 an. Auf Seite 9 ist
> auch ein schönes Beispiel, wie man Daten schreibt (Figure 3). Dazu musst
> du das RESET Pin eigentlich nicht beachten, weil das nur für das Löschen
> des RDAC Registers genutzt wird. Aber du kannst es auch einfach
> überschreiben.
> Ach...und wenn du den Widerstand des Potis ändern möchtest, musst du
> nach Zeile 2 der Tabelle 11 auf Seite 22 vorgehen.
>
> Nur so nebenbei PORTB = PORTB & 11... ist vom Stil her Quatsch. Eher
> PORTB=11...
>
> MfG
> guest111

Ja, du hast recht, dass meine Schaltung ziemlich unübersichtlich ist. Es 
hat aber auch Gründe, deshalb gebe ich eben nur den relevanten Teil 
preis. Generell sollte ich alles richtig angeschlossen haben:

SS (PB4) beim Atmega32 --> Pin 13 auf J4 des Eva-Boards --> SYNC (Pin 
12) beim AD5292

MOSI (PB5) beim Atmega32 --> Pin 14 auf J4 des Eva-Boards --> DIN (Pin 
10) beim AD5292

SCK (PB7) beim Atmega32 --> Pin 16 auf J4 des Eva-Boards --> SCLK (Pin 
11) beim AD5292

Mein C Code habe ich auch etwas abgeändert. Dabei habe ich mir das 
Timing Diagram von Seite 9 genauer angeschaut. Anfangs braucht man wohl 
eine fallende Flanke beim SYNC, um den Datentransfer zu aktivieren. Auf 
Seite 23 gibt es eine kleine Tabelle, die besagt, dass zuerst 0x1803 
geschrieben werden muss, damit der Chip überhaupt die Wiper-Position 
updaten kann. Anschließend habe ich kann ich erst Befehle #1 von Seite 
22 einschleusen (ich habe beispielsweise 0x0500 geschrieben. Jedoch 
klappt es weiterhin nicht, per DMM messe ich immer noch 10 KOhm, also 
der Wiper befindet sich immer noch in der Mitte.

Hier mein C Code:

#include <avr/io.h>
#include "spi.h"
#include <avr/interrupt.h>

#define PORT_SPI    PORTB
#define DDR_SPI     DDRB
#define DD_MISO     DDB6
#define DD_MOSI     DDB5
#define DD_SS       DDB4
#define DD_SCK      DDB7

void spi_init()
// Initialize pins for spi communication
{
  DDR_SPI &= ~((1<<DD_MOSI)|(1<<DD_MISO)|(1<<DD_SS)|(1<<DD_SCK));
  // Define the following pins as output
  DDR_SPI |= ((1<<DD_MOSI)|(1<<DD_SS)|(1<<DD_SCK));

  SPCR = ((1<<SPE)|               // SPI Enable
          (0<<SPIE)|              // SPI Interupt Enable
          (0<<DORD)|              // Data Order (0:MSB first / 1:LSB first)
          (1<<MSTR)|              // Master/Slave select
          (0<<SPR1)|(1<<SPR0)|    // SPI Clock Rate
          (0<<CPOL)|              // Clock Polarity (0:SCK low / 1:SCK hi when idle)
          (0<<CPHA));             // Clock Phase (0:leading / 1:trailing edge sampling)

  SPSR = (1<<SPI2X);              // Double Clock Rate
}
 
void spi_transmit_sync (uint8_t dataout)
// Shift full array to target device without receiving any byte
{
  SPDR = dataout;
  while((SPSR & (1<<SPIF))==0);
}

int main(void)
{  
  // Allocate variable
  uint8_t data_buf;
  // Initialize SPI
  spi_init();
  
  // SS high
  PORTB = 0b00001000;
  // SS low --> falling edge
  PORTB = 0b00000000;
  // Command #6 --> enable update of wiper position through digital interface
  data_buf = 0x18;
  spi_transmit_sync(data_buf);
  data_buf = 0x03;
  spi_transmit_sync(data_buf);
  // SS high
  PORTB = 0b00001000;
  
  // SS high
  PORTB = 0b00001000;
  // SS low --> falling edge
  PORTB = 0b00000000;
  // Command #1 --> wiper moves to 1/4 full-scale position
  data_buf = 0x50;
  spi_transmit_sync(data_buf);
  data_buf = 0x00;
  spi_transmit_sync(data_buf);
  // SS high  
  PORTB = 0b00001000;
}

Ich bin teilweise echt am verzweifeln. Über jeglichen Ratschlag und 
Hilfe wäre ich sehr dankbar!

[Purzel H. (hacky)]

Um mir solche Muehsale zu ersparen nehm ich fuer zeitunkritische 
Trivialitaeten jeweils einen Soft SPI, und bilde das vom Datenblatt 
verlangte timing einfach ueber die oroginalen SPI Portpins nach. Das hat 
man in 5 minuten erledigt.

[Cheng L. (cheng_l)]

Siebzehn mal Fuenfzehn schrieb:
> Um mir solche Muehsale zu ersparen nehm ich fuer zeitunkritische
> Trivialitaeten jeweils einen Soft SPI, und bilde das vom Datenblatt
> verlangte timing einfach ueber die oroginalen SPI Portpins nach. Das hat
> man in 5 minuten erledigt.

Okay, und wie würdest du es dann machen?

[dummy (Gast)]

// SS high
  PORTB = 0b00001000;

Dort wird PB3 auf High gezogen. SS ist aber PB4.

[Cheng L. (cheng_l)]

dummy schrieb:
> // SS high
>   PORTB = 0b00001000;
>
> Dort wird PB3 auf High gezogen. SS ist aber PB4.

Danke, dass du in meinem Code einen Fehler gefunden hast, aber es geht 
leider immer noch nicht...

[guest111 (Gast)]

Hast du denn nicht mal die Möglichkeit deine Bits zu überprüfen? Das 
macht es doch alles einfacher! Erst, wenn du sicher weist, dass die Bits 
an der richtigen Stelle ankommmen, kannst du verzweifeln :)

MfG
guest111

[Purzel H. (hacky)]

> ..Okay, und wie würdest du es dann machen?

Naja, im Datenblatt steht ja das timing, welche Signale sich wie zu 
verhalten haben. Das macht man dann eben genau so.

PORTB,4 = 1  usw.