M4 (samd51) läuft nicht als i2c master

[i2c_problem (Gast)]

Hallo Zusammen,

jemand eine Idee warum aus meinen Portpins PB08 und PB09 absolut kein 
Signal kommt?
Ich habe zum ersten mal versucht den i2c am atsamD51j18 aufzusetzen, und 
bisher scheitert es komplett. Es gab noch keinen einzigen Zucker an den 
beiden Portpins... Für meinen Geschmack müsste er wenigstens mal 
irgendwie zucken wenn z.B. das erste mal ins ADDR-Register geschrieben 
wird.
Die Konfiguration is grob aus Datenblatt und AN(AT11628 für samd21) 
zusammengeführt.

Hardwaretechnisch hängt an der anderen Seite über Pullups (4k4) nur ein 
DAC80501 im i2c-Betriebsmodus.

Wäre über hinweise sehr dankbar!

/*
 * Prototyp_1.c
 *
 * Created: 30.01.2020 11:07:41
 * Author : i2c
 */ 


#include "sam.h"
#include <stdbool.h>



#define CMD_DAC_DEVID 0b00000001
#define SLAVE_ADDR_DAC 0x72
#define BUF_SIZE 3




uint8_t tx_buf[BUF_SIZE]={1,2,3};
uint8_t rx_buf[BUF_SIZE];
uint8_t i;
volatile bool tx_done=false, rx_done=false;





void clk_init(void)
{
  
  // Clock von GCLK0 ausgeben auf PB14
  PORT->Group[1].PMUX[7].bit.PMUXE = 12; // Multiplex M
  PORT->Group[1].DIRSET.reg = PORT_PB14; // 48MHz ausgeben auf Portpin
  PORT->Group[1].PINCFG[14].reg = PORT_PINCFG_PMUXEN;
  GCLK->GENCTRL[0].reg =  GCLK_GENCTRL_OE |
              GCLK_GENCTRL_GENEN;
  
}





void i2c_init(void)
{
    
  //SERCOM4 Core mit Generic Clock Generator 0 verbinden und aktivieren
  GCLK->PCHCTRL[34].reg =  GCLK_PCHCTRL_CHEN |
              GCLK_PCHCTRL_GEN_GCLK0;
              
  MCLK->APBDMASK.bit.SERCOM4_ = 1;    // Main-Clock auf SERCOM4 aktivieren
  
  
  SERCOM4->I2CM.CTRLA.bit.SWRST = 1;    // Softwarereset für SERCOM4
  while(SERCOM4->I2CM.CTRLA.bit.SWRST | SERCOM4->I2CM.SYNCBUSY.bit.SWRST);  // warten bis reset fertig
  
  SERCOM4->I2CM.CTRLA.reg = SERCOM_I2CM_CTRLA_MODE(5) | // muss Wert 5 haben in Master-Config
                SERCOM_I2CM_CTRLA_INACTOUT(1); // 55US Inactive Time-Out

  SERCOM4->I2CM.CTRLB.reg = SERCOM_I2CM_CTRLB_SMEN;
  while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
  
  //SERCOM4->I2CM.CTRLC.reg = SERCOM_I2CM_CTRLC_DATA32B; // Dataregister mit 32 Bit beschreiben
  
  SERCOM4->I2CM.BAUD.reg = 59;  // Baudrate (400kb/s) 
  while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
  
  SERCOM4->I2CM.INTENSET.reg = SERCOM_I2CM_INTENSET_MB | SERCOM_I2CM_INTENSET_SB; // Interrupt
  
  SERCOM4->I2CM.STATUS.reg = SERCOM_I2CM_STATUS_BUSSTATE(1); 
  while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
  
  SERCOM4->I2CM.CTRLA.reg = SERCOM_I2CM_CTRLA_ENABLE;    // Aktivieren
  while(SERCOM4->I2CM.SYNCBUSY.bit.ENABLE);
  
  
  PORT->Group[1].PMUX[4].bit.PMUXO = 3;
  PORT->Group[1].PMUX[4].bit.PMUXE = 3;
    
  PORT->Group[1].PINCFG[8].reg = PORT_PINCFG_PMUXEN;
  PORT->Group[1].PINCFG[9].reg = PORT_PINCFG_PMUXEN;

  
  NVIC_DisableIRQ(SERCOM4_2_IRQn);
  NVIC_ClearPendingIRQ(SERCOM4_2_IRQn);
  NVIC_SetPriority(SERCOM4_2_IRQn, 0);
  NVIC_EnableIRQ(SERCOM4_2_IRQn);
  
  
  
}







void SERCOM4_Handler(void)
{
  
  /* Master on bus interrupt checking */
  if(SERCOM4->I2CM.INTFLAG.bit.MB)
  {
    if(i==BUF_SIZE)
    {
      /* After transferring the last byte stop condition will be sent */
      SERCOM4->I2CM.CTRLB.bit.CMD = 0x3;
      while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
      tx_done=true;
      i=0;
    }else
    {
      /* placing the data from transmitting buffer to DATA register*/
      SERCOM4->I2CM.DATA.reg = tx_buf[i++];
      while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
    }
  }
  
  /* Slave on bus interrupt checking */
  if(SERCOM4->I2CM.INTFLAG.bit.SB)
  {
    if(i==(BUF_SIZE-1))
    {
      /* NACK should be sent before reading the last byte */
      SERCOM4->I2CM.CTRLB.reg|=SERCOM_I2CM_CTRLB_ACKACT;
      while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
      
      SERCOM4->I2CM.CTRLB.bit.CMD=0x3;
      while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
      
      rx_buf[i++]=SERCOM4->I2CM.DATA.reg;
      while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);rx_done=true;
    }else
    {
      SERCOM4->I2CM.CTRLB.reg&=~SERCOM_I2CM_CTRLB_ACKACT;
      while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
      
      rx_buf[i++]=SERCOM4->I2CM.DATA.reg;
      while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
      
      /* sending ACK after reading each byte */
      SERCOM4->I2CM.CTRLB.bit.CMD=0x2;
      while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
    }
  }
  
  
}




void i2c_master_transact(void)
{
  i=0;
  
  /* Acknowledge section is set as ACKsignal by writing 0 in ACKACT bit */
  SERCOM4->I2CM.CTRLB.reg &= ~SERCOM_I2CM_CTRLB_ACKACT;
  while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
  
  /* slave address with Write(0) */
  SERCOM4->I2CM.ADDR.reg = (SLAVE_ADDR_DAC<<1) | 0;
  while(!tx_done);
  
  i=0;
  
  /* Acknowledge section is set as ACK signal by writing 0 in ACKACT bit */
  SERCOM4->I2CM.CTRLB.reg &= ~SERCOM_I2CM_CTRLB_ACKACT;
  while(SERCOM4->I2CM.SYNCBUSY.bit.SYSOP);
  
  /* slave address with read (1) */
  SERCOM4->I2CM.ADDR.reg = (SLAVE_ADDR_DAC<<1) | 1;
  while(!rx_done);
  
  /*interrupts are cleared */
  SERCOM4->I2CM.INTENCLR.reg = SERCOM_I2CM_INTENCLR_MB | SERCOM_I2CM_INTENCLR_SB;
  
}






void sleep(uint32_t count)
{
  for(;count>0;count--)
  {
    asm volatile("NOP");
  }
}











int main(void)
{
  
  __enable_irq();
  
  clk_init();
  

  i2c_init();
  
  
  

    while (1) 
    {
    
    i2c_master_transact();

    
        
    sleep(500);
        
    
    
    }
}

[Peter D. (peda)]

Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Und nicht kiloweise unnötig Leerzeilen lassen.

[Kondensator (Gast)]

Pullupwiderstand drin?

[Stephan (Gast)]

Sicher, dass es nicht P_A_09 und 08 sind?

und#1:
ich vermissse so etwas in der Art:

void i2c_pin_init(){
  pin_set_peripheral_function(PINMUX_PA08D_SERCOM2_PAD0);
  pin_set_peripheral_function(PINMUX_PA09D_SERCOM2_PAD1);
}

und#2:
PullUp 4k7 ist meiner unmassgeblichen Erfahrung nach VIEL zu hoch...
Ich nehme in 3V3 Systemen 1k .. 2k2 (je nach Leitungslänge, I2C-Speed 
und potenziellen Störern); Aber das wird natürlich erst relevant, WENN 
aus den (richtigen) Ports etwas herauskommt...

VG, Stephan

[Rudolph (Gast)]

Also PB08 und PB09 passen zumindest zu SERCOM4.

Vielleicht mal so konfigurieren:

REG_PORT_WRCONFIG1 =
 PORT_WRCONFIG_HWSEL |
 PORT_WRCONFIG_WRPINCFG |
 PORT_WRCONFIG_WRPMUX |
 PORT_WRCONFIG_PMUX(3) | /* SERCOM4 */
 PORT_WRCONFIG_DRVSTR |
 PORT_WRCONFIG_PINMASK(0x0003) | /* PB08 + PB09 */
 PORT_WRCONFIG_PMUXEN;

[i2c_problem (Gast)]

@Rudolph
hat leider nichts geändert.


@Stephan

  PORT->Group[1].PMUX[4].bit.PMUXO = 3;
  PORT->Group[1].PMUX[4].bit.PMUXE = 3;
    
  PORT->Group[1].PINCFG[8].reg = PORT_PINCFG_PMUXEN;
  PORT->Group[1].PINCFG[9].reg = PORT_PINCFG_PMUXEN;

Das sollte die Pins entsprechend schalten. Und ja für SERCOM4 wollte ich 
PB08 und PB09.






*@all*
Ich habe jetzt auch schon diverse andere Pins und SERCOM-Schnittstellen 
versucht, leider ohne Erfolg. Beim duchgehen im Debugger (Atmelstudio) 
erkennt man auch diverse Änderungen der Register während der 
Initialisierung. Wenn ich dann aber in i2c_master_transact() in das 
ADDR-Register schreibe ändert sich im Register nichts(oder es wird 
zumindest nicht angezeigt).

Scheint wohl eher etwas grundlegendes zu sein... noch jemand Ideen oder 
vllt eine funktionsfähige Version?

[Stephan (Gast)]

Ich würde bei der Fehlersuche trotzdem ganz unten anfangen...
Also feststellen, ob der SCK Pin überhaupt gesetzt gelöscht werden kann, 
gleiches für SDA... wenn da so garnix rauskommt tippe ich auf ein port 
initialisierungsproblem. Ich kenne aber den D51/SERCON nicht; benutze 
selbst den SAM4S, da ist an der Stelle ein bisschen traditioneller Stoff 
gefragt.

[Peter D. (peda)]

Geh dochmal systematisch vor.
Prüfe, ob die Pins überhaupt ansprechbar sind und dann probiere ein 
SW-I2C.
Wenn Du eh im Main wartest, ist HW-I2C auch nicht schneller, nur viel 
komplizierter und störempfindlicher.

[i2c_problem (Gast)]

SERCOM4->I2CM.CTRLA.reg = SERCOM_I2CM_CTRLA_ENABLE;    // Aktivieren

hier fehlt ein "|" vor dem "=" .... damit wird der "MODE" überschrieben 
und es nicht als Master initialisiert....grrrrrrrrrrrrrr
Besten Dank für die Hinweise/Hilfe

[Rudolph (Gast)]

i2c_problem schrieb:
> @Rudolph
> hat leider nichts geändert.

Das war im Detail auch Unsinn, irgendwie hatte ich spontan die Idee, 
dass das WRCONFIG Register nur 8 Pins konfiguriert.

PORT->Group[1].WRCONFIG.reg =
  PORT_WRCONFIG_WRPINCFG |
  PORT_WRCONFIG_WRPMUX |
  PORT_WRCONFIG_PMUX(3) |    /* SERCOM4 */
  PORT_WRCONFIG_DRVSTR |
  PORT_WRCONFIG_PINMASK(0x0300) | /* PB08 + PB09 */
  PORT_WRCONFIG_PMUXEN;


Weil das sowieso schon länger sinnlos herum liegt habe ich gerade mal 
den I2C auf einem SAMC21 grundsätzlich zum Laufen gebracht.
Die Peripherie ist mit dem SAMD51/SAME51 ja weitgehend identisch, der 
SAMD51 hat nur von allem noch viel mehr.

#include "sam.h"

volatile uint8_t system_tick = 0;

void SysTick_Handler(void)
{
  system_tick = 42;
}


void init_clock(void)
{
  REG_NVMCTRL_CTRLB = NVMCTRL_CTRLB_RWS(2);  // Set the NVM Read Wait States to 2, Since the operating frequency will be 48 MHz

  REG_OSCCTRL_XOSCCTRL =  OSCCTRL_XOSCCTRL_STARTUP(6) |    // 1,953 ms
              OSCCTRL_XOSCCTRL_RUNSTDBY |
              OSCCTRL_XOSCCTRL_AMPGC |
              OSCCTRL_XOSCCTRL_GAIN(3) |
              OSCCTRL_XOSCCTRL_XTALEN |
              OSCCTRL_XOSCCTRL_ENABLE;

  while((REG_OSCCTRL_STATUS & OSCCTRL_STATUS_XOSCRDY) == 0);

  /* configure the PLL, source = XOSC, pre-scaler = 8, multiply by 24 -> 48MHz clock from 16MHz input */
  REG_OSCCTRL_DPLLCTRLB = OSCCTRL_DPLLCTRLB_DIV(3) | OSCCTRL_DPLLCTRLB_REFCLK(1); // setup PLL to use XOSC input
  REG_OSCCTRL_DPLLRATIO = OSCCTRL_DPLLRATIO_LDRFRAC(0x0) | OSCCTRL_DPLLRATIO_LDR(23);
  REG_OSCCTRL_DPLLCTRLA = OSCCTRL_DPLLCTRLA_RUNSTDBY | OSCCTRL_DPLLCTRLA_ENABLE;
  while((REG_OSCCTRL_DPLLSTATUS & OSCCTRL_DPLLSTATUS_CLKRDY) != 0); // wait for the pll to be ready

  REG_GCLK_GENCTRL0 = GCLK_GENCTRL_DIV(0) |
            GCLK_GENCTRL_RUNSTDBY |
            GCLK_GENCTRL_GENEN |
            //GCLK_GENCTRL_SRC_XOSC |
            GCLK_GENCTRL_SRC_DPLL96M |
            GCLK_GENCTRL_IDC ;

  while((REG_GCLK_SYNCBUSY & GCLK_SYNCBUSY_GENCTRL0) != 0);  // wait for the synchronization between clock domains is complete
}


void init_io(void)
{
  REG_PORT_DIRSET0 = PORT_PA27; /* Debug-LED */
  REG_PORT_DIRSET0 = PORT_PA22; /* CAN_EN_1 */
  REG_PORT_DIRSET0 = PORT_PA23; /* CAN_STB_1 */

  REG_PORT_OUTSET0 = PORT_PA22; /* CAN_EN_1 */
  REG_PORT_OUTSET0 = PORT_PA23; /* CAN_STB_1 */
}


void init_i2c(void)
{
  /* configure SERCOM1 SCL PA17 and SERCOM1 SDA on PA16 */
  PORT->Group[0].WRCONFIG.reg =
    PORT_WRCONFIG_HWSEL |
    PORT_WRCONFIG_WRPINCFG |
    PORT_WRCONFIG_WRPMUX |
    PORT_WRCONFIG_PMUX(2) |    /* SERCOM1 */
    PORT_WRCONFIG_DRVSTR |
    PORT_WRCONFIG_PINMASK(0x0003) | /* PA16 + PA17 */
    PORT_WRCONFIG_PMUXEN;

  REG_MCLK_APBCMASK |= MCLK_APBCMASK_SERCOM1;
  GCLK->PCHCTRL[20].reg = GCLK_PCHCTRL_GEN_GCLK0 | GCLK_PCHCTRL_CHEN; /* setup SERCOM1 to use GLCK0 -> 48MHz */
  SERCOM1->I2CM.CTRLA.reg = 0x00; /* disable SERCOM1 -> enable config */
  SERCOM1->I2CM.CTRLA.reg = SERCOM_I2CM_CTRLA_MODE(5); /* I2C Master */
  SERCOM1->I2CM.BAUD.reg = SERCOM_I2CM_BAUD_BAUD(239); /* 48 / (2 * (baudval + 1)) -> @48Mhz: 239 = 100kHz */
  SERCOM1->I2CM.CTRLB.reg = SERCOM_I2CM_CTRLB_SMEN;
  SERCOM1->I2CM.CTRLA.reg |= SERCOM_I2CM_CTRLA_ENABLE; /* activate SERCOM1 */
  while(SERCOM1->I2CM.SYNCBUSY.reg & SERCOM_I2CM_SYNCBUSY_ENABLE); /* wait for SERCOM1 to be ready */
}


int main(void)
{
  uint8_t led_delay = 0;
  uint8_t i2c_delay = 0;
  
  init_clock();
  init_io();
  init_i2c();

  SysTick_Config(48000000 / 200); /* configure and enable Systick for 5ms ticks */

  while (1)
  {
    if(system_tick)
    {
      system_tick = 0;
      
      led_delay++;
      if(led_delay > 39)
      {
        led_delay = 0;
        REG_PORT_OUTTGL0 = PORT_PA27;
      }

      i2c_delay++;
      if(i2c_delay > 49)
      {
        i2c_delay = 0;
        SERCOM1->I2CM.ADDR.reg = 23;
      }
    }
  }
}

Das ist jetzt funktional nur ein Test, damit zappeln meine I2C Pins aber 
wenigstens.

[Rudolph (Gast)]

Damn, zu langsam, aber dafür bin ich auch einen Schritt weiter in 
Richtung I2C - falls das doch irgendwann mal benötigt werden sollte...). 
:-)

[i2c_problem (Gast)]

@Rudolph

ja, minimal zu langsam. Trotzdem vielen Dank für die Mühe!

[Peter D. (peda)]

i2c_problem schrieb:
> SERCOM4->I2CM.CTRLA.reg = SERCOM_I2CM_CTRLA_ENABLE;    // Aktivieren
>
> hier fehlt ein "|" vor dem "=" .... damit wird der "MODE" überschrieben
> und es nicht als Master initialisiert....grrrrrrrrrrrrrr

Solche mehrfachen Zugriffe auf das selbe Register sind eigentlich immer 
potentielle Fallgruben.
Ich setze daher immmer alle nötigen Bits auf einmal. Dann brauche ich 
mir nicht zu merken, was mal irgendwann früher gesetzt wurde.
Diese |= und &= Orgien mag ich nicht.

[Rudolph R. (rudolph)]

Peter D. schrieb:
> Solche mehrfachen Zugriffe auf das selbe Register sind eigentlich immer
> potentielle Fallgruben.
> Ich setze daher immmer alle nötigen Bits auf einmal. Dann brauche ich
> mir nicht zu merken, was mal irgendwann früher gesetzt wurde.
> Diese |= und &= Orgien mag ich nicht.

Eleganter wäre das so:

SERCOM1->I2CM.CTRLA.bit.ENABLE = 1; /* activate SERCOM1 */

Der Punkt ist halt, das setzen des ENABLE Bits und das kurze Warten 
darauf, dass das passiert ist, macht schon Sinn so am Ende der 
Initialisierung.
Denn im Gegensatz zu den AVR werden bei den ATSAM die meisten Bits in 
den meisten Registern gesperrt, sobald die Peripherie-Einheit aktiviert 
ist.
Also mindestens bei den ATSAMD2x, ATSAMC2x und ATSAMD/ATSAME5x ist das 
so.

Man kann zum Beispiel nicht einfach so den SPI Takt ändern,
man muss das ENABLE der SERCOM Einheit löschen, auf SYNCBUSY_ENABLE 
warten, kann dann das BAUD Register neu schreiben, ENABLE wieder setzen 
und noch mal auf SYNCBUSY_ENABLE warten.

Ausgesuchte Bits wie RXEN beim SPI sind davon ausgenommen.
Andere wie CPOL und CPHA sind aber gesperrt, was schon mal lästig sein 
kann.

Wenn man da lustig alles auf einmal setzt muss das nicht unbedingt den 
gewünschten Effekt haben.

Und das ist auch nur Level 1 der Absicherung.
Level 2 wäre den PAC - Peripheral Access Controller - anzuwerfen und 
noch mehr zu sperren, dann bekommt man sogar einen Access Violation 
Interrupt wenn doch ein Schreib-Zugriff passiert.