DsPIC33 und LIS3LV02DL --I²C Probleme--XC16 Compiler

[Patti W. (pat_w)]

Guten Abend allerseits,

ich habe ein Problem, und zwar bekomme ich meinen Beschleunigungssensor 
nicht richtig ausgelesen. Verwendet wird ein dspic33ep256mu806. Ich 
versuche den LIS3LV02DL per I²C auslesen.

Dazu konfiguriere ich die Register CTRL_1 und CTRL_2 und will dann 
erstmal das untere Byte der x- Achse des Sensors mittels polling 
dauerhaft abrufen. Das Byte welches sich ja dann permanent ändern sollte 
wenn ich die Platine bewege möchte ich mir auf meinem Oszilloskop 
angucken. Das Problem dabei ist auch das ich mir nur Mittels Oszilloskop 
den Bus angucken kann, jedoch nicht die Möglichkeit habe ein Display 
oder UART oder ähnliches anzuschließen und mir das Datenbyte ausgeben 
kann.

Mir wachsen langsam graue Haare, vielleicht kann mir ja wer helfen;)

Vielen Dank schonmal.

Grüße
pat_w

Die Main

#include "xc.h"
#include "i2c_func.h"
#include "i2c.h"
#include "stdio.h"
#include "stdlib.h"
#include "libpic30.h"
#include <p33EP256MU806.h>

#define WRITEAddress        0x3A   
#define READAddress         0x3B   
#define REG1         0x20
#define REG2         0x21
#define OUTX_L       0x28               //Unteres Byte der X-Achse
#define OUTX_H       0x29               //Oberes Byte der X-Achse
#define OUTY_L       0x2A
#define OUTY_H       0x2B
#define OUTZ_L       0x2C
#define OUTZ_H       0x2D
#define _XTAL_FREQ 12000000
#define FCY 12000000UL




// FGS
#pragma config GWRP = OFF               // General Segment Write-Protect bit (General Segment may be written)
#pragma config GSS = OFF                // General Segment Code-Protect bit (General Segment Code protect is disabled)
#pragma config GSSK = OFF               // General Segment Key bits (General Segment Write Protection and Code Protection is Disabled)

// FOSCSEL
#pragma config FNOSC = PRIPLL           // Initial Oscillator Source Selection bits (Primary Oscillator (XT, HS, EC) with PLL)
#pragma config IESO = ON                // Two-speed Oscillator Start-up Enable bit (Start up device with FRC, then switch to user-selected oscillator source)

// FOSC
#pragma config POSCMD = EC              // Primary Oscillator Mode Select bits (EC (External Clock) Mode)
#pragma config OSCIOFNC = ON           // OSC2 Pin Function bit (OSC2 is clock output)
#pragma config IOL1WAY = OFF            // Peripheral pin select configuration (Allow multiple reconfigurations)
#pragma config FCKSM = CSDCMD           // Clock Switching Mode bits (Both Clock switching and Fail-safe Clock Monitor are disabled)

// FWDT
#pragma config WDTPOST = PS32768        // Watchdog Timer Postscaler bits (1:32,768)
#pragma config WDTPRE = PR128           // Watchdog Timer Prescaler bit (1:128)
#pragma config PLLKEN = ON              // PLL Lock Wait Enable bit (Clock switch to PLL source will wait until the PLL lock signal is valid.)
#pragma config WINDIS = OFF             // Watchdog Timer Window Enable bit (Watchdog Timer in Non-Window mode)
#pragma config FWDTEN = OFF             // Watchdog Timer Enable bit (Watchdog timer enabled/disabled by user software)

// FPOR
#pragma config FPWRT = PWR128           // Power-on Reset Timer Value Select bits (128ms)
#pragma config BOREN = ON               // Brown-out Reset (BOR) Detection Enable bit (BOR is enabled)
#pragma config ALTI2C1 = OFF            // Alternate I2C pins for I2C1 (SDA1/SCK1 pins are selected as the I/O pins for I2C1)

// FICD
#pragma config ICS = PGD2               // ICD Communication Channel Select bits (Communicate on PGEC2 and PGED2)
#pragma config RSTPRI = PF              // Reset Target Vector Select bit (Device will obtain reset instruction from Primary flash)
#pragma config JTAGEN = ON              // JTAG Enable bit (JTAG is enabled)

// FAS
#pragma config AWRP = OFF               // Auxiliary Segment Write-protect bit (Aux Flash may be written)
#pragma config APL = OFF                // Auxiliary Segment Code-protect bit (Aux Flash Code protect is disabled)
#pragma config APLK = OFF               // Auxiliary Segment Key bits (Aux Flash Write Protection and Code Protection is Disabled)





int main(void) {
    unsigned char data=0;
    
    __delay32(24000000);
    
    
    i2c_init(128);

    i2c_start();
    I2Cwrite(WRITEAddress,REG1,0xC7);           //CTRL Register 1 
    i2c_restart();
    I2Cwrite(WRITEAddress,REG2,0x40);           //CTRL Register 2
    reset_i2c_bus();
    __delay32(24000000);
    while (1) {
        i2c_start();
        data = I2Cread(WRITEAddress,0x27);                  //OutX_L auslesen
        reset_i2c_bus();
        __delay32(6000000);
    }

    return 0;
}

Die Header

// This is a guard condition so that contents of this file are not included
// more than once.  
#ifndef XC_HEADER_TEMPLATE_H
#define  XC_HEADER_TEMPLATE_H

#include <xc.h> // include processor files - each processor file is guarded.  


#ifdef  __cplusplus
extern "C" {
#endif /* __cplusplus */

    void i2c_init(int BRG);
    void i2c_start(void);
    void i2c_restart(void);
    void reset_i2c_bus(void);
    char send_i2c_byte(int data);
    char i2c_read(void);
    char i2c_read_ack(void);
    void I2Cwrite(char addr, char subaddr, char value);
    char I2Cread(char addr, char subaddr);
    unsigned char I2Cpoll(char addr);

#ifdef  __cplusplus
}
#endif /* __cplusplus */

#endif  /* XC_HEADER_TEMPLATE_H */

Die Headerfunktionen

#include <i2c.h>
#include <libpic30.h>
#include "i2c_func.h"
//function initiates I2C1 module to baud rate BRG
void i2c_init(int BRG)
{
   int temp;

   // I2CBRG = 194 for 10Mhz OSCI with PPL with 100kHz I2C clock
   I2C2BRG = BRG;
   I2C2CONbits.I2CEN = 0;  // Disable I2C Mode
   I2C2CONbits.DISSLW = 1;  // Disable slew rate control
   IFS3bits.MI2C2IF = 0;   // Clear Interrupt
   I2C2CONbits.I2CEN = 1;  // Enable I2C Mode
   temp = I2C2RCV;   // read buffer to clear buffer full
   reset_i2c_bus();   // set bus to idle
}


//function iniates a start condition on bus
void i2c_start(void)
{
   int x = 0;
   I2C2CONbits.ACKDT = 0;  //Reset any previous Ack
   __delay32(36);
   I2C2CONbits.SEN = 1;  //Initiate Start condition
   Nop();

   //the hardware will automatically clear Start Bit
   //wait for automatic clear before proceding
   while (I2C2CONbits.SEN)
   {
      __delay32(12);
      x++;
      if (x > 20)
      break;
   }
   __delay32(24);
}


void i2c_restart(void)
{
   int x = 0;

   I2C2CONbits.RSEN = 1;  //Initiate restart condition
   Nop();
    
   //the hardware will automatically clear restart bit
   //wait for automatic clear before proceding
   while (I2C2CONbits.RSEN)
   {
      __delay32(12);
      x++;
      if (x > 20)  break;
   }
    
   __delay32(24);
}


//Resets the I2C bus to Idle
void reset_i2c_bus(void)
{
   int x = 0;

   //initiate stop bit
   I2C2CONbits.PEN = 1;

   //wait for hardware clear of stop bit
   while (I2C2CONbits.PEN)
   {
      __delay32(12);
      x ++;
      if (x > 20) break;
   }
   I2C2CONbits.RCEN = 0;
   //IFS1bits.MI2C1IF = 0; // Clear Interrupt
   IFS3bits.MI2C2IF = 0;
   I2C2STATbits.IWCOL = 0;
   I2C2STATbits.BCL = 0;
    __delay32(120);
}


//basic I2C byte send
char send_i2c_byte(int data)
{
   int i;

   while (I2C2STATbits.TBF) { }
  // IFS1bits.MI2C1IF = 0; // Clear Interrupt
   IFS3bits.MI2C2IF = 0;
   I2C2TRN = data; // load the outgoing data byte

   // wait for transmission
   for (i=0; i<500; i++)
   {
      if (!I2C2STATbits.TRSTAT) break;
      __delay32(12);

      }
      if (i == 500) {
      return(1);
   }

   // Check for NO_ACK from slave, abort if not found
   if (I2C2STATbits.ACKSTAT == 1)
   {
      reset_i2c_bus();
      return(1);
   }
   
   __delay32(24);
   return(0);
}

//function reads data, returns the read data, no ack
char i2c_read(void)
{
   int i = 0;
   char data = 0;

   //set I2C module to receive
   I2C2CONbits.RCEN = 1;

   //if no response, break
   while (!I2C2STATbits.RBF)
   {
      i ++;
      if (i > 2000) break;
   }

   //get data from I2CRCV register
   data = I2C2RCV;
           //set nack
      I2C2CONbits.ACKEN = 0;

   //wait before exiting
   __delay32(120);


   //return data
   return data;
}



//function reads data, returns the read data, with ack
char i2c_read_ack(void)  //does not reset bus!!!
{
   int i = 0;
   char data = 0;

   //set I2C module to receive
   I2C2CONbits.RCEN = 1;

   //if no response, break
   while (!I2C2STATbits.RBF)
   {
      i++;
      if (i > 2000) break;
   }

   //get data from I2CRCV register
   data = I2C2RCV;

   //set ACK to high
   I2C2CONbits.ACKEN = 1;

   //wait before exiting
   __delay32(120);

   //return data
   return data;
}


void I2Cwrite(char addr, char subaddr, char value)
{
   i2c_start();
   send_i2c_byte(addr);
   send_i2c_byte(subaddr);
   send_i2c_byte(value);
   reset_i2c_bus();
}

char I2Cread(char addr, char subaddr)
{
   char temp;
   
   i2c_start();
   send_i2c_byte(addr);
   send_i2c_byte(subaddr);
   __delay32(120);

   i2c_restart();
   send_i2c_byte(addr | 0x01);
   temp = i2c_read();

   reset_i2c_bus();
   return temp;
}

unsigned char I2Cpoll(char addr)
{
   unsigned char temp = 0;

   i2c_start();
   temp = send_i2c_byte(addr);
   reset_i2c_bus();

   return temp;
}