I2C Master mit STM32F

[Mike R. (thesealion)]

Hallo,

ich versuche zur Zeit mit einem Cortex-M3 (STM32F102RB) mit einem X9258 
Poti zu kommunizieren. Leider klappt das nicht und vor allem weiß ich 
nicht ob die Hardware I2C Schnittstelle von ST das überhaupt kann.
Das Problem ist da Protokoll des Potis. Das möchte etwas in der Form:

Start, Adresse (ohne read/write), Befehl (vom Master), Daten (vom 
Slave), Ende

haben, also ein umschalten der Übertragungsrichtung während der 
Kommunikation. Hab ich die Möglichkeit das zu tun bisher einfach nur 
übersehen oder können die STM32F.. Chips das tatsächlich nicht?

Gruß Mike

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

Mike S. schrieb:
> Das Problem ist da Protokoll des Potis.
> ... ein umschalten der Übertragungsrichtung während der Kommunikation.
Du weißt schon, wie I²C funktioniert?
Es wird niemals eine '1' ausgegeben. Eine '1' ergibt sich über einen 
Pullup automatisch, wenn keiner eine '0' ausgibt...

Deshalb ist jeder Pin (SCL und SDA) immer gleichzeitig Aus- und Eingang 
(und das muss er sein, denn bei I²C kann/könnte ein Slvae den Takt 
selbständig verlängern!!!).

[Johannes V. (Gast)]

Funktioniert bei meinem 103RB sehr gut.

Ohne ein Datenblatt gelesen zu haben, würde deine I2C Kommunikation so 
ablaufen:

Master started, Master schickt Addresse mit Read, Slave ACKed, Master 
schickt Befehl, Slave ACKed, Master stopt

Master started, Master schickt Addresse mit Write, Slave ACKed, Master 
empfängt byte (Ack oder nack, je nachdem ob es das letzte byte ist), 
Master stopt.

I2Cslot X9258(Addresse, Port);

unsigned char befehl[2] = { 1, 'bla' };
unsigned char antwort[2] = { 1, 0x00 };

if(X9258.send(befehl) != 0)
printf("Fehler!");
if(X9258.recv(antwor) != 0)
printf("Fehler!");

class I2Cslot{
  unsigned char address;    // holds address of this slot
  unsigned char port;      // number of this slots port

public:
  /*  Constructor to create slots for devices  */
  I2Cslot(unsigned char address, unsigned char port);
  /*  initializes all active I2C ports  */
  static void init();
  /*  send a number of bytes with on this slot, number has to be in the first spot of the string pMsg points at */
  /*  returns 0 if no error occured of the transaction  */
  int send(unsigned char *pMsg);
  /*  receive a number of bytes with on this slot, number has to be in the first spot of the string pMsg points at  */
  /*  returns 0 if no error occured of the transaction  */
  int recv(unsigned char *pMsg);
  
  /* same as regular functions, but busy lopping instead of switching the task */
  int send_sync(unsigned char *pMsg);
  int recv_sync(unsigned char *pMsg);
};

#include "STM32_I2C.h"
#include "STM32_DriverInterna.h"
#include <stm32f10x.h>
#ifdef DEBUG
#include <stdio.h>
#endif

#define Core__Frequency 72000000

#define I2C_NO_MUTEX
#define I2C1__active  //port0.0 SDA1, port0.1 SCL1
//#define I2C2__active  //port0.10 SDA2, port0.11 SCL2




I2Cslot::I2Cslot(unsigned char address, unsigned char port)
{
  this->address = address;
  this->port = port - 1;
}

extern "C" {

void I2C1_EV_IRQHandler(void);
void I2C2_EV_IRQHandler(void);

void I2C1_ER_IRQHandler(void);
void I2C2_ER_IRQHandler(void);


struct {
  unsigned char *pMsg;
  volatile char error;
  unsigned char count;
  unsigned char address;
#ifndef I2C_NO_MUTEX
  CTL_MUTEX_t mutex;
#endif
}I2C[1];
}

void I2Cslot::init()
{
#ifdef I2C1__active
  I2C1->CR2 = (3 << 8) | 0x24;        // set APB clock 36MHz and  [enable IRQs : Error, Buffer, Event I2C1->CR2 = (7 << 8)]
  I2C1->CCR = (1 << 15)|(1<<14)|27;   // enable fast mode 19:9 
    I2C1->TRISE = 11;
  I2C1->CR1 = 1;                      //I2C enable
#ifndef I2C_NO_MUTEX
  ctl_mutex_init(&I2C[0].mutex);
#endif
  ctl_set_isr(31, 10, I2C1_EV_IRQHandler, 0);
  ctl_unmask_isr(31);
    ctl_set_isr(32, 10, I2C1_ER_IRQHandler, 0);
  ctl_unmask_isr(32);
#endif
#ifdef I2C2__active
  I2C2->CR2 = (7 << 8) | 0x24;    // set APB clock 36MHz and enable IRQs : Error, Buffer, Event
  I2C2->CCR = (1 << 15)|(1<<14)|23;      // enable fast mode 19:9 
    I2C2->TRISE = 11;
  I2C2->CR1 = 1;                  //I2C enable
  ctl_mutex_init(&I2C[1].mutex);
  ctl_set_isr(33, 10, I2C2_EV_IRQHandler, 0);
  ctl_unmask_isr(31);
    ctl_set_isr(34, 10, I2C2_ER_IRQHandler, 0);
  ctl_unmask_isr(32);
#endif
}


int I2Cslot::send(unsigned char *pMsg)
{
#ifdef DEBUG
  printf("I2C: %d Bytes to %X\n", pMsg[0], address);
#endif
#ifndef I2C_NO_MUTEX
  ctl_mutex_lock(&I2C[port].mutex, CTL_TIMEOUT_NONE, 0);
#endif
  I2C[port].pMsg = pMsg;  //adjust pointer to msg
  I2C[port].error = 1;  //initialize error
  I2C[port].count = 1;  //initialize counter
  I2C[port].address = address;
  switch(port)
  {
#ifdef I2C1__active
  case 0:
    I2C1->CR1 |= 0x100;    //generate start condition
    WaitStatus_I2C1;    //wait for hardware to complete the operation
    break;
#endif
#ifdef I2C2__active
  case 1:
    I2C2->CR2 |= 0x100;    //generate start condition
    WaitStatus_I2C2;    //wait for hardware to complete the operation
    break;
#endif
  default:
    while(1);        //trying to access inactive port
  }
#ifdef DEBUG
  if(I2C[port].error)
    printf("I2Cerror: %X", I2C[port].error);
#endif
#ifndef I2C_NO_MUTEX
  ctl_mutex_unlock(&I2C[port].mutex);
#endif
  return I2C[port].error;
}

int I2Cslot::recv(unsigned char *pMsg)
{
  address++;
  int temp = send(pMsg);
  address--;
  return (temp);
}

int I2Cslot::send_sync(unsigned char *pMsg)
{
#ifdef DEBUG
  printf("I2C%d: %d Bytes to %X\n", port, pMsg[0], address);
#endif
#ifndef I2C_NO_MUTEX
  ctl_mutex_lock(&I2C[port].mutex, CTL_TIMEOUT_NONE, 0);
#endif
  I2C[port].pMsg = pMsg;  //adjust pointer to msg
  I2C[port].error = 1;  //initialize error
  I2C[port].count = 1;  //initialize counter
  I2C[port].address = address;
  switch(port)
  {
#ifdef I2C1__active
  case 0:
    I2C1->CR1 = 0x101;    //generate start condition
    break;
#endif
#ifdef I2C2__active
  case 1:
    I2C2->CR1 = 0x101;    //generate start condition    
    break;
#endif
  default:
    while(1);        //trying to access inactive port
  }
  
  
    while(I2C[port].error == 1)
      ;
  
 
#ifdef DEBUG
  if(I2C[port].error)
    printf("I2C%derror: %X", port, I2C[port].error);
#endif
#ifndef I2C_NO_MUTEX     
  ctl_mutex_unlock(&I2C[port].mutex);
#endif
  return I2C[port].error;
}

int I2Cslot::recv_sync(unsigned char *pMsg)
{
  address++;
  int temp = send_sync(pMsg);
  address--;
  return (temp);
}

extern "C" {
#ifdef I2C1__active
void I2C1_EV_IRQHandler (void)
{
    ctl_enter_isr();

    static int status2 = 0;
  int status1 = I2C1->SR1;
    

    if(status1 & 0x01)                  // start bit was send
    {
        I2C1->DR = I2C[0].address;      // first transmit the address
    }
    else if( status1 & 0x02 )           // address transmitted and ACK received
    {
        status2 = I2C1->SR2;            // read 2nd status register to clear it
        if( ~status2 & 0x04 )           // Receiver mode, determine ACK return
        {
            if( I2C[0].pMsg[0] > 1 )    // there's more than one byte to receive, set ACK return bit
                I2C1->CR1 = 0x401;
            else
                I2C1->CR1 = 0x201;      // else there is only one byte to be received, set the STOP bit
        }
    }

    if ( status1 & 0x84 )               // if BTF or TxE bit is set we need to write/read a new byte
    {
        if( status2 & 0x04 )            // write if in transmitter mode
        {
            if( I2C[0].count <= I2C[0].pMsg[0] )
            {                           // if not all bytes have been transmitted yet, keep on pushing
                I2C1->DR = I2C[0].pMsg[I2C[0].count];
                I2C[0].count++;
            }
            else                        // the last byte was transmitted, shut down the interface
            {
                I2C[0].error = 0;       // we done
                I2C1->CR1 = 0x201;      // set stop bit
                StatusSet_I2C1;
            }
        }
        else                            // else in receiver mode
        {                               // read the byte just received
            I2C[0].pMsg[I2C[0].count] = I2C1->DR;
            I2C[0].count++;
            if( I2C[0].count == I2C[0].pMsg[0] )
                I2C1->CR1 = 0x201;      // clear the ACK bit and Set the STOP bit for the next byte to be received
            else if( I2C[0].count > I2C[0].pMsg[0] )
            {
                I2C[0].error = 0;       // we done
                StatusSet_I2C1;
            }
        }
    } 

    ctl_exit_isr();
}

void I2C1_ER_IRQHandler(void)
{
    ctl_enter_isr();
    
    int err = I2C1->SR1;    
    I2C1->SR1 = 0;          // write a zero to clear all flags
    if( err & 0x400 )       // NACK received
    {
        I2C1->CR1 = 0x201;  // set a stop
        I2C[0].error = 0xFE;
        StatusSet_I2C1;
    }
    if( err & 0x200 )       // arbitration lost
    {
        I2C[0].error = 0xFF;
        StatusSet_I2C1;
    }
    
    if( I2C[0].count > I2C[0].pMsg[0] ) // indicates that the transfer was completed but a NACK on last byte? possible :/
        while(1);
    
    ctl_exit_isr();
}
#endif
}

[Johannes V. (johannes_v)]

Ok,

es hat mich wirklich stutzig gemacht und du hast Recht.
Anscheinend muss tatsächlich zwischen write und read während dem 
Transfer gewechselt werden und die Slave Addresse hat keinen Einfluss 
auf die Datenrichtung.

Als ich mich mit dem STM I2C auseinandergesetzt habe ist mir eine 
ähnliche Funktion auch nicht untergekommen. Verübeln kann man es ihnen 
aber auch nicht, ist schließlich absoluter Humbug und entspricht nicht 
dem Standard.

Unter Umständen wirsd du nicht drum rumkommen ein Software I2C zu 
schreiben um das Poti zu verwenden, da die Hardware Statusmaschienen 
sich logischerweise nur nach dem R/W Bit der Addresse richten.

Viel Glück

[Mike R. (thesealion)]

Ok, danke für die Info. Dann habe ich das Datenblatt ja wohl doch 
richtig gelesen.
Das mit dem zweiten Start kenne ich auch von solchen Devices wie EEROMs, 
aber die Potis haben halt eine total "eigene" Interpretation :-(