ADE7758 via SPI

[Jan H. (janiiix3)]

Hallo Community,

ich bekomme es einfach nicht hin ein Register auszulesen.
Normalerweise sollte ich bei Register "0x48" einen default Wert von 
"0x3F" bekommen.

Bekommen tue ich aber 255.
Es scheint als ob ich meine SPI Initalisierung nicht im Griff habe.

Woher weiß ich denn mit welchem "Mode" ich arbeiten muss für den Chip?

Hier die Initalisierung (Arbeiten tue ich mit einem MEGA32U4) :

void spi_master_init(uint8_t prescaler, uint8_t clock_option)
{  
  /* ONLY FOR MEGA32! */
  #if defined(__AVR_ATmega32__)
  {
    /* set MOSI and SCK output, all others input */
    MOSI_DDR |= (1<<MOSI_BIT);
    SCK_DDR   |=  (1<<SCK_BIT);
    SS_DDR   |= (1<<SS_BIT);
  
    /* enable SPI, Master */
    SPCR |= (1<<SPE)|(1<<MSTR);
    
    /* clear the bit´s (for multi init) */
    SPCR &= ~((1<<SPI2X) | (1<<SPR0) | (1<<SPR1)); // fclk/4
  
    /* config SPI Bus Speed fclk/prescaler */
    switch (prescaler)
    {
      case 2:   {SPCR |=  (1<<SPI2X);               };break;
      case 8:   {SPCR |=  ((1<<SPI2X) | (1<<SPR0));       };break;
      case 32:  {SPCR |=  ((1<<SPI2X) | (1<<SPR1));       };break;
      case 64:  {SPCR |=  ((1<<SPI2X) | (1<<SPR1) | (1<<SPR0));};break;
      default:  {SPCR |=  (1<<SPI2X);               };break;
    }
  }
  #endif  
  
  /* ONLY FOR MEGA32U4! */
  #if defined (__AVR_ATmega32U4__)
  {
      /* set MOSI and SCK output, all others input */
      MOSI_DDR |= (1<<MOSI_BIT);
      SCK_DDR   |=  (1<<SCK_BIT);
      SS_DDR   |= (1<<SS_BIT);
      
      /* enable SPI, Master */
      SPCR |= ((1<<SPE) | (1<<MSTR));      
      
      /* config "Clock Polarity and "Clock Phase" */
      switch(clock_option)
      {
        case 0 : {SPCR &= ~((1<<CPOL) | (1<<CPHA)); }break; // mode 1
        case 1 : {SPCR |=  (1<<CPHA);        }break; // mode 2
        case 2 : {SPCR |=  (1<<CPOL);        }break; // mode 3
        case 3 : {SPCR |=  ((1<<CPOL) | (1<<CPHA));  }break; // mode 4
      }
      
      /* config SPI Bus Speed fclk/prescaler */
      switch (prescaler)
      {
        case 2:   {SPSR |= (1<<SPI2X);                  }break; // prescaler 2
        case 8:   {SPSR |= (1<<SPI2X); SPCR |= (1<<SPR0);        }break; // prescaler 8
        case 32:  {SPSR |= (1<<SPI2X); SPCR |= (1<<SPR1);        }break; // prescaler 32
        case 64:  {SPSR |= (1<<SPI2X); SPCR |= (1<<SPR1) | (1<<SPR0); }break; // prescaler 64
        default:  {SPSR |= (1<<SPI2X);                  }break; // default = 2
      }
  }
  #endif

}

[Joe F. (easylife)]

Die verschiedenen SPI Modes sind hier ganz anschaulich erklärt:
https://de.wikipedia.org/wiki/Serial_Peripheral_Interface#/media/File:SPI_timing_diagram2.svg

SCLK soll im nicht aktiven Zustand low sein
-> CPOL=0

Aus Figure 3 und Figure 4 des ADE7758 Datenblattes siehst du, dass die 
Daten immer auf steigender Clock Flanke wechseln, also auf fallender 
Flanke übernommen werden.
-> CPHA=1

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Jan H. schrieb:
> Bekommen tue ich aber 255.
Brücke mal MOSI und MISO am Master. Dann solltest du bei inaktivem oder 
ausgebautem Slave genau das zurück bekommen, was du sendest.

Insgesamt ist für die Fehlersuche an einem solchen seriellen Bus ein 
Oszilloskop sehr brauchbar. Hast du sowas?

[Jan H. (janiiix3)]

Lothar M. schrieb:
> Jan H. schrieb:
>> Bekommen tue ich aber 255.
> Brücke mal MOSI und MISO am Master. Dann solltest du bei inaktivem oder
> ausgebautem Slave genau das zurück bekommen, was du sendest.
>
> Insgesamt ist für die Fehlersuche an einem solchen seriellen Bus ein
> Oszilloskop sehr brauchbar. Hast du sowas?

Hallo Lothar,

das mit dem Brücken ist eine sehr gute Idee.
Vermutlich liegt das Problem wirklich nur an der Initalisierung.
Werde es direkt mal mit dem Oszi nachvollziehen.
Vielen lieben dank schonmal ;)

[Jan H. (janiiix3)]

Also wenn ich es Brücke, bekomme ich genau den Wert zurück den ich auch 
sende.

int main(void)
{
  
  DDRD |= (1<<PD5);  
  lcd_init(LCD_DISP_ON);
  spi_master_init(64,3);
  
  sei();  


    while (1) 
    {
    spi_master_transmit(cnt);
    cnt = spi_receive();
    
    _delay_ms(250);    
    
    if (cnt == 63)
    {
      PORTD ^= (1<<PD5);  
    }
    
    lcd_gotoxy(2,0);
    lcd_puts("");
    lcd_gotoxy(1,1);
    sprintf(Buffer,"read : %d ", cnt);
    lcd_puts(Buffer);
    
    cnt++;
        
        
    }
}

[Joe F. (easylife)]

Na, dann versuche es doch mal mit der langsamsten Geschwindigkeit 
(prescaler=64) und CPOL0/CPHA1 (clock_option=1)...

also

spi_master_init(64, 1);

[Jan H. (janiiix3)]

Joe F. schrieb:
> Na, dann versuche es doch mal mit der langsamsten Geschwindigkeit
> (prescaler=64) und CPOL0/CPHA1 (clock_option=1)...
>
> also
>
> spi_master_init(64, 1);

Funzt natürlich auch nicht.
Am Chip (also Slave) muss ich doch nur Versorgungsspannung anlegen, 
DOUT, DIN, SCLK und SS = Masse schalten oder?

[Joe F. (easylife)]

Jan H. schrieb:
> SS = Masse

SS heist "Slave Select" und darf nicht dauerhaft auf GND sein...

Im Datenblatt ist dieses Signal mit "CS" bezeichnet.

[Jan H. (janiiix3)]

Joe F. schrieb:
> Jan H. schrieb:
>> SS = Masse
>
> SS heist "Slave Select" und darf nicht dauerhaft auf GND sein...
>
> Im Datenblatt ist dieses Signal mit "CS" bezeichnet.

Ich habe es auch schon Probiert mit einer "fallenden Flanke".

[Joe F. (easylife)]

Jan H. schrieb:
> Ich habe es auch schon Probiert mit einer "fallenden Flanke".

Verstehe nicht, was das heissen soll.

CS (SS) ist ein Signal, das zu jeder SPI Übertragung dazugehört.

Du selektiert den entsprechenden Slave, bestimmst mit der fallenden 
Flanke den Anfang der Übertragung, und mit steigender Flanke wird das 
Ende der Übertragung angezeigt, und der Slave deselektiert.

Vermutlich fehlt dies alles bei dir.

Guck mal ins Datenblatt, Figure 3 und 4 (Serial Write Timing, Serial 
Read Timing), da siehst du genau, wie sich CS verhalten muss.

Vor dem ersten transmit muss also CS von high auf low gesetzt werden, 
und nach dem letzten write oder read wieder auf high.

[Jan H. (janiiix3)]

Joe F. schrieb:
> Jan H. schrieb:
>> Ich habe es auch schon Probiert mit einer "fallenden Flanke".
>
> Verstehe nicht, was das heissen soll.
>
> CS (SS) ist ein Signal, das zu jeder SPI Übertragung dazugehört.
>
> Du selektiert den entsprechenden Slave, bestimmst mit der fallenden
> Flanke den Anfang der Übertragung, und mit steigender Flanke wird das
> Ende der Übertragung angezeigt, und der Slave deselektiert.
>
> Vermutlich fehlt dies alles bei dir.
>
> Guck mal ins Datenblatt, Figure 3 und 4 (Serial Write Timing, Serial
> Read Timing), da siehst du genau, wie sich CS verhalten muss.

Okay. Ist mir neu. Habe ich bis jetzt noch bei keinem gesehen.
Meinste das in etwa so ?

char ADE7758_read8bit(char reg)
{
  char ret=0;
  
  _delay_us(10);
  SS_PORT |= (1<<SS_BIT);
  SS_PORT &= ~(1<<SS_BIT);
  spi_master_transmit(reg);
  _delay_us(10);
  ret = spi_receive();
  SS_PORT |= (1<<SS_BIT);
  _delay_us(10);
  
  return ret;
}

[Joe F. (easylife)]

Jan H. schrieb:
> Okay. Ist mir neu. Habe ich bis jetzt noch bei keinem gesehen.

Tja, man lernt immer etwas dazu.

> Meinste das in etwa so ?

Ja. Der Master muss allerdings auch beim Read die Clock treiben, 
insofern weiss ich nicht, ob spi_receive() die geeignete Funktion ist.

Hast du ein header-filer der verfügbaren SPI Funktionen?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Jan H. schrieb:
> Habe ich bis jetzt noch bei keinem gesehen.
Sieh dir das Datenblatt des ICs an. Wenn dort im Timingdiagramm der SS 
(höchstwahrscheinlich) zum Beginn einer Übertragung au Low und danach 
auf High geht, dann ist der für die Übertragungssynchronisierung nötig.

Oder andersrum:
Der SCLK ist der Schiebetakt für die SPI Flipflops, und der SS ist das 
Übernahmesignal für ein ganzes Wort.

Sieh dir das mal an:
http://www.lothar-miller.de/s9y/archives/15-SPI.html

[Jan H. (janiiix3)]

Joe F. schrieb:
> Jan H. schrieb:
>> Okay. Ist mir neu. Habe ich bis jetzt noch bei keinem gesehen.
>
> Tja, man lernt immer etwas dazu.
>
>> Meinste das in etwa so ?
>
> Ja. Der Master muss allerdings auch beim Read die Clock treiben,
> insofern weiss ich nicht, ob spi_receive() die geeignete Funktion ist.
>
> Hast du ein header-filer der verfügbaren SPI Funktionen?

Ja, habe ich mir selber erstellt. Das meiste habe ich aus dem 
Datenblatt.
Da wird es auch nicht gemacht mit dem Synchronisationsbit.
Was aber eigentlich eine gute Sache ist.

Werde es morgen direkt mal ausprobieren.


Also wenn ich etwas übertragen will... Von "High" --> "Low" und der 
Slave schickt dann doch direkt die Daten raus, da muss ich den "SS" 
nicht mehr schalten oder?

[Joe F. (easylife)]

Die unendlichen Weiten des Interwebs verraten mir, dass du folgendes tun 
solltest:

WRITE:

SS_PORT &= ~(1<<SS_BIT); // slave select low
spi_master_transmit(0x80 | reg);
spi_master_transmit(data_msb);
(...)
spi_master_transmit(data_lsb);
SS_PORT |= (1<<SS_BIT); // slave select high


READ:

SS_PORT &= ~(1<<SS_BIT); // slave select low
spi_master_transmit(reg);
data_msb = spi_master_transmit(0);
(...)
data_lsb = spi_master_transmit(0);
SS_PORT |= (1<<SS_BIT); // slave select high

[Joe F. (easylife)]

Jan H. schrieb:
> Also wenn ich etwas übertragen will... Von "High" --> "Low" und der
> Slave schickt dann doch direkt die Daten raus, da muss ich den "SS"
> nicht mehr schalten oder?

Nein.
Du hast weder das Prinzip von SPI (dass es ein Bus ist, und jeder Slave 
per SS selektiert werden muss, und auch nur dann antworten darf, wenn er 
selektiert ist),

noch das Protokoll deines ICs verstanden.

Lies dich bitte in SPI ein, und dann in das Datenblatt deines ICs.

Dein IC hat Register, die mit einem Write addressiert werden müssen, und 
erst dann kannst du die entsprechenden Registerdaten auslesen.
Zu beachten ist noch, dass bei der Adressierung das oberste Bit dem 
Slave sagt, ob du das Register beschreiben willst, oder den Inhalt 
auslesen möchtest (siehe auch Code oben).

spi_master_transmit() schreibt ein Byte zum Slave und liest auch 
gleichzeitig vom Slave (das ist dann der Rückgabewert).
Bei einem Read muss der Master allerdings die Clock treiben, daher macht 
man üblicherweise einen Write mit einem Null-Byte, und interessiert sich 
dann für die Daten, die der Slave gleichzeitig gesendet hat.

[Jan H. (janiiix3)]

Joe F. schrieb:
> spi_master_transmit() schreibt ein Byte zum Slave und liest auch
> gleichzeitig vom Slave (das ist dann der Rückgabewert).
> Bei einem Read muss der Master allerdings die Clock treiben, daher macht
> man üblicherweise einen Write mit einem Null-Byte, und interessiert sich
> dann für die Daten, die der Slave gleichzeitig gesendet hat.

Ich denke das übernimmt die Hardware? Wie würde das konkret aussehen?

[Joe F. (easylife)]

so
Beitrag "Re: ADE7758 via SPI"

guck mal unter READ

für jedes Byte, das du (der Master) vom Slave lesen möchtest, sendest du 
gleichzeitig eine "0", damit die Clock getrieben wird.
Was der Slave während des Sendens der "0" auf MISO zurückliefert, 
liefert die Funktion spi_master_transmit() dann als Rückgabewert.

Die Register deines ICs sind unterschiedlich "breit". Es gibt welche mit 
8, andere mit 16, andere mit 24 Bit (1, 2, 3 Bytes).
Daher musst du die Funktionen zum Beschreiben und Auslesen der Register 
entsprechend flexibel machen, oder du schreibst entsprechend 3 
verschiedene Funktionen.
Ich habe das mit den "(...)" angedeutet.

[Jan H. (janiiix3)]

Okay, dass hat geklappt. Es war wirklich nur das "dummy" Byte was 
gefehlt hat.

Eine Frage habe ich jedoch noch. Wenn ich jetzt meine Phasen (A,B,C) 
einlesen und berechnen möchte, wo steht das im DB beschrieben? Ich finde 
dazu nichts.

Weiß nur das es ein "24 Bit" Register ist.

[Joe F. (easylife)]

Im Datenblatt 
http://www.analog.com/media/en/technical-documentation/data-sheets/ADE7758.pdf
sind in Table 17 alle Register aufgeführt.
Ich weiss nicht, welche Information über die Phasen dich interessiert.
Angenommen es wäre "Phase A Current RMS", also Register 0x0a (=10)

Da dieses Register 24 bit breit ist:

uint8_t reg;

uint8_t data_2;
uint8_t data_1;
uint8_t data_0;

uint32_t data;

reg = 0x0a;

SS_PORT &= ~(1<<SS_BIT); // slave select low
spi_master_transmit(reg);
data_2 = spi_master_transmit(0);
data_1 = spi_master_transmit(0);
data_0 = spi_master_transmit(0);
SS_PORT |= (1<<SS_BIT); // slave select high

data = ((uint32_t)(data_2) << 16) | 
       ((uint32_t)(data_1) <<  8) |
       ((uint32_t)(data_0));

[Jan H. (janiiix3)]

Joe F. schrieb:
> Im Datenblatt
> http://www.analog.com/media/en/technical-documenta...
> sind in Table 17 alle Register aufgeführt.
> Ich weiss nicht, welche Information über die Phasen dich interessiert.
> Angenommen es wäre "Phase A Current RMS" ist das Register 0x0a (=10)
>
> Da das Register 24 bit breit ist:
> uint8_t reg;
>
> uint8_t data_2;
> uint8_t data_1;
> uint8_t data_0;
>
> uint32_t data;
>
> reg = 0x0a;
>
> SS_PORT &= ~(1<<SS_BIT); // slave select low
> spi_master_transmit(reg);
> data_2 = spi_master_transmit(0);
> data_1 = spi_master_transmit(0);
> data_0 = spi_master_transmit(0);
> SS_PORT |= (1<<SS_BIT); // slave select high
>
> data = ((uint32_t)(data_2) << 16) |
>        ((uint32_t)(data_1) <<  8) |
>        ((uint32_t)(data_0));




Ich möchte gerne mal die Spannung von "Phase_A" lesen was muss da noch 
gerechnet werden?

[Joe F. (easylife)]

Jan H. schrieb:
> Ich möchte gerne mal die Spannung von "Phase_A" lesen was muss da noch
> gerechnet werden?

Naja, also sorry.
Das steht auch im Datenblatt, ich habe jetzt aber echt keine Lust, ein 
72-seitiges Datenblatt durchzuarbeiten, weil du zu faul dazu bist.
Im Unterschied zu dir werde ich nicht für diese Arbeit bezahlt.

Gut zu hören, dass die SPI Kommunikation jetzt funktioniert.

[Jan H. (janiiix3)]

Joe F. schrieb:
> Jan H. schrieb:
>> Ich möchte gerne mal die Spannung von "Phase_A" lesen was muss da noch
>> gerechnet werden?
>
> Naja, also sorry.
> Das steht auch im Datenblatt, ich habe jetzt aber echt keine Lust, ein
> 72-seitiges Datenblatt durchzuarbeiten, weil du zu faul dazu bist.
> Im Unterschied zu dir werde ich nicht für diese Arbeit bezahlt.
>
> Gut zu hören, dass die SPI Kommunikation jetzt funktioniert.

Von wem werde ich denn bezahlt???
Ich finde halt nirgends im Datenblatt wie ich die Werte verrechnen muss 
für die Spannung.

[Joe F. (easylife)]

Jan H. schrieb:
> Von wem werde ich denn bezahlt???

Weiss ich nicht, war nur eine Vermutung, da du offensichtlich tagsüber 
dran arbeitest...

> Ich finde halt nirgends im Datenblatt wie ich die Werte verrechnen muss
> für die Spannung.

S. 29, "Voltage Channel RMS Calculation"

Da steht:
"The equivalent rms value of a full-scale ac signal is approximately 
1,639,101 (0x1902BD) in the VRMS register."

Full-scale AC Signal ist 0.5V, die Zahl oben bezieht sich auf 60Hz.
Aus Figure 64 rechts oben kann man dann aber auch den Wert für 50Hz 
herauslesen:

0x193504 = 1,651,972

D.h. du teilst den Registerwert durch 3303944 (=2*1651972) und erhältst 
Volt.
Oder durch 3304, ergibt dann mV.