I2C Kommunitkation funktioniert nicht

[Florian M. (lauch_henne)]

Hallo liebe Community,

erstmal frohes neues Jahr!
Leider beginnt meines nicht ganz so toll.
Ich möchte einfach nur einen Temperatursensor (DS1621) auslesen. Dabei 
hapert es schon an der Initialisierung der I2C-Peripherie, was mich 
stutzig macht, da in der Headerdatei nur die I2C0-Schnittstelle 
behandelt werden. Aber was ist mit den anderen beiden? Bis hin zum Code, 
über den vielleicht ein Experte hier im Forum mal einen Blick 
drüberwerfen könnte?
An meinem LCD wird immer nur eine 0 angezeigt..
Ich habe zwei 4,7 kOhm Pullups angelötet.


Es geht mir anfangs nur mal darum, dass ich überhaupt Temperaturen 
angezeigt bekomme (keine Nachkommastellen).
Ich hoffe ihr könnt mir da weiterhelfen, wie ich die Peripherie korrekt 
einstelle, und sagen was ich an dem Code noch ändern müsste?!
Ich benutze als IDE: CooCox mit dem ARM-GCC Compiler..
Die Bibliotheken habe ich von keil.

Vielen Dank!!
main.c:

/*
#include "lpc17xx_timer.h"
#include "lpc17xx_clkpwr.h"
#include "lc798x.h"
#include "lpc17xx.h"  
#include "i2c.h"

//Definition der DS1621 Befehle bzw. Register
#define START_CONVERT_TEMP      0xEE   
#define READ_TEMPERATURE  0xAA    
#define DS1621_ADDR             0x90  //Schreibender Zugriff
#define DS1621_Read    0x91   //lesender Zugriff
#define PORT_USED 0


extern volatile uint8_t I2CMasterBuffer[I2C_PORT_NUM][BUFSIZE];
extern volatile uint8_t I2CSlaveBuffer[I2C_PORT_NUM][BUFSIZE];
extern volatile uint32_t I2CReadLength[I2C_PORT_NUM];
extern volatile uint32_t I2CWriteLength[I2C_PORT_NUM];



int main(void)
{
 
  int byte1;
  int byte2;
  
  int temp;  



  TimerInit(0, 1000);  

  I2C1Init();               //I2C initilisieren auf P0.0 und P0.1
  int portused = 1;                                                             
  init_lcd();


  
  I2CWriteLength[PORT_USED] = 2;      
  I2CReadLength[PORT_USED] = 0;      
  I2CMasterBuffer[PORT_USED][0] = DS1621_ADDR;  
  I2CMasterBuffer[PORT_USED][1] = START_CONVERT_TEMP;
  //I2CMasterBuffer[PORT_USED][2] = DS1621_ADDR | RD_BIT; //Nötig?
  I2CEngine(PORT_USED);
  delayMs(0,1000);
  
  while(1)  
 {

    delayMs(0,1000);
  I2CWriteLength[PORT_USED] = 1;
  I2CReadLength[PORT_USED]= 2;    //nämlich die zwei Slave Buffers?!
  I2CMasterBuffer[PORT_USED][0] = DS1621_ADDR;
  I2CMasterBuffer[PORT_USED][1] = READ_TEMPERATURE;
  I2CMasterBuffer[PORT_USED][2] = DS1621_Read;
  I2CEngine(PORT_USED);

  byte1 = I2CSlaveBuffer[0][0];      //MSB                        
  byte2 = I2CSlaveBuffer[1][1];      //LSB

      //var = ...; Hier sollen die Bytes konvertiert weden  
      temp = var...;
    
    printf("Grad in Celsius: %d",temp);
            delayMs(0,500);

  }
}

i2c.h:

#ifndef __I2C_H 
#define __I2C_H

/* If I2C SEEPROM is tested, make sure FAST_MODE_PLUS is 0.
For board to board test, this flag can be turned on. */

#define FAST_MODE_PLUS      0

#define I2C_PORT_NUM        3
#define BUFSIZE             64
#define MAX_TIMEOUT         0x00FFFFFF

static LPC_I2C_TypeDef (* const LPC_I2C[I2C_PORT_NUM]) = { LPC_I2C0, LPC_I2C1, LPC_I2C2 };

#define I2CMASTER           0x01
#define I2CSLAVE            0x02

#define PCF8594_ADDR        0x28
#define READ_WRITE          0x01

#define RD_BIT              0x01

#define I2C_IDLE              0
#define I2C_STARTED           1
#define I2C_RESTARTED         2
#define I2C_REPEATED_START    3
#define DATA_ACK              4
#define DATA_NACK             5
#define I2C_BUSY              6
#define I2C_NO_DATA           7
#define I2C_NACK_ON_ADDRESS   8
#define I2C_NACK_ON_DATA      9
#define I2C_ARBITRATION_LOST  10
#define I2C_TIME_OUT          11
#define I2C_OK                12

#define I2CONSET_I2EN       (0x1<<6)  /* I2C Control Set Register */
#define I2CONSET_AA         (0x1<<2)
#define I2CONSET_SI         (0x1<<3)
#define I2CONSET_STO        (0x1<<4)
#define I2CONSET_STA        (0x1<<5)

#define I2CONCLR_AAC        (0x1<<2)  /* I2C Control clear Register */
#define I2CONCLR_SIC        (0x1<<3)
#define I2CONCLR_STAC       (0x1<<5)
#define I2CONCLR_I2ENC      (0x1<<6)

#define I2DAT_I2C      0x00000000  /* I2C Data Reg */
#define I2ADR_I2C      0x00000000  /* I2C Slave Address Reg */
#define I2SCLH_SCLH      0x00000080  /* I2C SCL Duty Cycle High Reg */
#define I2SCLL_SCLL      0x00000080  /* I2C SCL Duty Cycle Low Reg */
#define I2SCLH_HS_SCLH    0x00000008  /* Fast Plus I2C SCL Duty Cycle High Reg */
#define I2SCLL_HS_SCLL    0x00000008  /* Fast Plus I2C SCL Duty Cycle Low Reg */

extern void I2C0_IRQHandler( void );
extern void I2C1_IRQHandler( void );
extern void I2C2_IRQHandler( void );
extern void I2C0Init( void );
extern void I2C1Init( uint32_t select );
extern void I2C2Init( void );
extern uint32_t I2CStart( uint32_t portNum );
extern uint32_t I2CStop( uint32_t portNum );
extern uint32_t I2CEngine( uint32_t portNum );

extern volatile uint8_t I2CMasterBuffer[I2C_PORT_NUM][BUFSIZE];
extern volatile uint8_t I2CSlaveBuffer[I2C_PORT_NUM][BUFSIZE];
extern volatile uint32_t I2CReadLength[I2C_PORT_NUM];
extern volatile uint32_t I2CWriteLength[I2C_PORT_NUM];

#endif /* end __I2C_H */

i2c.c

 #include "lpc17xx.h"
#include "lpc_types.h"
#include "i2c.h"

volatile uint32_t I2CMasterState[I2C_PORT_NUM] = {I2C_IDLE,I2C_IDLE,I2C_IDLE};
volatile uint32_t timeout[I2C_PORT_NUM] = {0, 0, 0};

volatile uint8_t I2CMasterBuffer[I2C_PORT_NUM][BUFSIZE];
volatile uint8_t I2CSlaveBuffer[I2C_PORT_NUM][BUFSIZE];
volatile uint32_t I2CCount[I2C_PORT_NUM] = {0, 0, 0};
volatile uint32_t I2CReadLength[I2C_PORT_NUM];
volatile uint32_t I2CWriteLength[I2C_PORT_NUM];

volatile uint32_t RdIndex0 = 0, RdIndex1 = 0, RdIndex2 = 0;
volatile uint32_t WrIndex0 = 0, WrIndex1 = 0, WrIndex2 = 0;


/* 
From device to device, the I2C communication protocol may vary, 
in the example below, the protocol uses repeated start to read data from or 
write to the device:
For master read: the sequence is: STA,Addr(W),offset,RE-STA,Addr(r),data...STO 
for master write: the sequence is: STA,Addr(W),offset,RE-STA,Addr(w),data...STO
Thus, in state 8, the address is always WRITE. in state 10, the address could 
be READ or WRITE depending on the I2C command.
*/   

/*****************************************************************************
** Function name:    I2C_IRQHandler
**
** Descriptions:    I2C interrupt handler, deal with master mode only.
**
** parameters:      None
** Returned value:    None
** 
*****************************************************************************/
void I2C0_IRQHandler(void) 
{
  uint8_t StatValue;

  timeout[0] = 0;
  /* this handler deals with master read and master write only */
  StatValue = LPC_I2C0->I2STAT;
  switch ( StatValue )
  {
  case 0x08:      /* A Start condition is issued. */
  WrIndex0 = 0;
  LPC_I2C0->I2DAT = I2CMasterBuffer[0][WrIndex0++];
  LPC_I2C0->I2CONCLR = (I2CONCLR_SIC | I2CONCLR_STAC);
  break;

  case 0x10:      /* A repeated started is issued */
  RdIndex0 = 0;
  /* Send SLA with R bit set, */
  LPC_I2C0->I2DAT = I2CMasterBuffer[0][WrIndex0++];
  LPC_I2C0->I2CONCLR = (I2CONCLR_SIC | I2CONCLR_STAC);
  break;

  case 0x18:      /* Regardless, it's a ACK */
  if ( I2CWriteLength[0] == 1 )
  {
    LPC_I2C0->I2CONSET = I2CONSET_STO;      /* Set Stop flag */
    I2CMasterState[0] = I2C_NO_DATA;
  }
  else
  {
    LPC_I2C0->I2DAT = I2CMasterBuffer[0][WrIndex0++];
  }
  LPC_I2C0->I2CONCLR = I2CONCLR_SIC;
  break;

  case 0x28:  /* Data byte has been transmitted, regardless ACK or NACK */
  if ( WrIndex0 < I2CWriteLength[0] )
  {
    LPC_I2C0->I2DAT = I2CMasterBuffer[0][WrIndex0++]; /* this should be the last one */
  }
  else
  {
    if ( I2CReadLength[0] != 0 )
    {
    LPC_I2C0->I2CONSET = I2CONSET_STA;  /* Set Repeated-start flag */
    }
    else
    {
    LPC_I2C0->I2CONSET = I2CONSET_STO;      /* Set Stop flag */
    I2CMasterState[0] = I2C_OK;
    }
  }
  LPC_I2C0->I2CONCLR = I2CONCLR_SIC;
  break;

  case 0x30:
  LPC_I2C0->I2CONSET = I2CONSET_STO;      /* Set Stop flag */
  I2CMasterState[0] = I2C_NACK_ON_DATA;
  LPC_I2C0->I2CONCLR = I2CONCLR_SIC;
  break;

  case 0x40:  /* Master Receive, SLA_R has been sent */
  if ( (RdIndex0 + 1) < I2CReadLength[0] )
  {
    /* Will go to State 0x50 */
    LPC_I2C0->I2CONSET = I2CONSET_AA;  /* assert ACK after data is received */
  }
  else
  {
    /* Will go to State 0x58 */
    LPC_I2C0->I2CONCLR = I2CONCLR_AAC;  /* assert NACK after data is received */
  }
  LPC_I2C0->I2CONCLR = I2CONCLR_SIC;
  break;

  case 0x50:  /* Data byte has been received, regardless following ACK or NACK */
  I2CSlaveBuffer[0][RdIndex0++] = LPC_I2C0->I2DAT;
  if ( (RdIndex0 + 1) < I2CReadLength[0] )
  {
    LPC_I2C0->I2CONSET = I2CONSET_AA;  /* assert ACK after data is received */
  }
  else
  {
    LPC_I2C0->I2CONCLR = I2CONCLR_AAC;  /* assert NACK on last byte */
  }
  LPC_I2C0->I2CONCLR = I2CONCLR_SIC;
  break;

  case 0x58:
  I2CSlaveBuffer[0][RdIndex0++] = LPC_I2C0->I2DAT;
  I2CMasterState[0] = I2C_OK;
  LPC_I2C0->I2CONSET = I2CONSET_STO;  /* Set Stop flag */
  LPC_I2C0->I2CONCLR = I2CONCLR_SIC;  /* Clear SI flag */
  break;

  case 0x20:    /* regardless, it's a NACK */
  case 0x48:
  LPC_I2C0->I2CONSET = I2CONSET_STO;      /* Set Stop flag */
  I2CMasterState[0] = I2C_NACK_ON_ADDRESS;
  LPC_I2C0->I2CONCLR = I2CONCLR_SIC;
  break;

  case 0x38:    /* Arbitration lost, in this example, we don't
          deal with multiple master situation */
  default:
  I2CMasterState[0] = I2C_ARBITRATION_LOST;
  LPC_I2C0->I2CONCLR = I2CONCLR_SIC;
  break;
  }
  return;
}
/*****************************************************************************
** Function name:    I2CStart
**
** Descriptions:    Create I2C start condition, a timeout
**        value is set if the I2C never gets started,
**        and timed out. It's a fatal error.
**
** parameters:      None
** Returned value:    true or false, return false if timed out
** 
*****************************************************************************/
uint32_t I2CStart( uint32_t portNum )
{
  uint32_t retVal = FALSE;
 
  timeout[portNum] = 0;
  /*--- Issue a start condition ---*/
  LPC_I2C[portNum]->I2CONSET = I2CONSET_STA;  /* Set Start flag */
    
  /*--- Wait until START transmitted ---*/
  while( 1 )
  {
  if ( I2CMasterState[portNum] == I2C_STARTED )
  {
    retVal = TRUE;
    break;
  }
  if ( timeout[portNum] >= MAX_TIMEOUT )
  {
    retVal = FALSE;
    break;
  }
  timeout[portNum]++;
  }
  return( retVal );
}

/*****************************************************************************
** Function name:    I2CStop
**
** Descriptions:    Set the I2C stop condition, if the routine
**        never exit, it's a fatal bus error.
**
** parameters:      None
** Returned value:    true or never return
** 
*****************************************************************************/
uint32_t I2CStop( uint32_t portNum )
{
  LPC_I2C[portNum]->I2CONSET = I2CONSET_STO;      /* Set Stop flag */
  LPC_I2C[portNum]->I2CONCLR = I2CONCLR_SIC;  /* Clear SI flag */
            
  /*--- Wait for STOP detected ---*/
  while( LPC_I2C[portNum]->I2CONSET & I2CONSET_STO );
  return TRUE;
}

/*****************************************************************************
** Function name:    I2CInit
**
** Descriptions:    Initialize I2C controller as a master
**
** parameters:      None
** Returned value:    None
** 
*****************************************************************************/
void I2C0Init( void ) 
{
  LPC_SC->PCONP |= (1 << 7);

  /* set PIO0.27 and PIO0.28 to I2C0 SDA and SCL */
  /* function to 01 on both SDA and SCL. */
  LPC_PINCON->PINSEL1 &= ~((0x03<<22)|(0x03<<24));
  LPC_PINCON->PINSEL1 |= ((0x01<<22)|(0x01<<24));
 
  /*--- Clear flags ---*/
  LPC_I2C0->I2CONCLR = I2CONCLR_AAC | I2CONCLR_SIC | I2CONCLR_STAC | I2CONCLR_I2ENC;

  /*--- Reset registers ---*/
#if FAST_MODE_PLUS
  LPC_PINCON->I2CPADCFG |= ((0x1<<0)|(0x1<<2));
  LPC_I2C0->SCLL   = I2SCLL_HS_SCLL;
  LPC_I2C0->SCLH   = I2SCLH_HS_SCLH;
#else
  LPC_PINCON->I2CPADCFG &= ~((0x1<<0)|(0x1<<2));
  LPC_I2C0->I2SCLL   = I2SCLL_SCLL;
  LPC_I2C0->I2SCLH   = I2SCLH_SCLH;
#endif

  /* Install interrupt handler */
  NVIC_EnableIRQ(I2C0_IRQn);

  LPC_I2C0->I2CONSET = I2CONSET_I2EN;
  return;
}
/*****************************************************************************
** Function name:    I2CEngine
**
** Descriptions:    The routine to complete a I2C transaction
**            from start to stop. All the intermitten
**            steps are handled in the interrupt handler.
**            Before this routine is called, the read
**            length, write length, I2C master buffer,
**            and I2C command fields need to be filled.
**            see i2cmst.c for more details.
**
** parameters:      I2C port number
** Returned value:    master state of current I2C port.
** 
*****************************************************************************/
uint32_t I2CEngine( uint32_t portNum ) 
{
  /*--- Issue a start condition ---*/
  LPC_I2C[portNum]->I2CONSET = I2CONSET_STA;  /* Set Start flag */

  I2CMasterState[portNum] = I2C_BUSY;

  while ( I2CMasterState[portNum] == I2C_BUSY )
  {
  if ( timeout[portNum] >= MAX_TIMEOUT )
  {
    I2CMasterState[portNum] = I2C_TIME_OUT;
    break;
  }
  timeout[portNum]++;
  }
  LPC_I2C[portNum]->I2CONCLR = I2CONCLR_STAC;

  return ( I2CMasterState[portNum] );
}

[Florian M. (lauch_henne)]

Ok, das Problem mit dem Konfigurieren der Peripherie habe ich jetzt 
lösen können.
Die Headerdatei war einfach nicht vollständig.