BMP280 an PIC18F45K42 mit MPLAP und I2C

[Brom B. (schrori)]

Hallo zusammen,

leider komme ich aktuell nicht wirklich weiter.
Ich möchte mit dem PIC18F45K42 via I2C auslesen. Leider finde ich zum 
BMP280 keine Bibliothek die für MPLAP geeignet ist und auch meine 
Versuche die anderen Bibliotheken umzuschreiben sind gescheitert.

Auch "Anleitungen" für den 18F4550 habe ich gefunden, doch nutzt diese 
nicht MCC sondern schreibt direkt in die Register welche sich von den 
Registern in meinem Controller stark unterscheiden.

Ich möchte lediglich den Luftdruck messen. es wäre toll wenn mir jemand 
helfen könnte. Bzw. würde es schon helfen wenn ich schaffe Bytes zu 
senden und zu empfangen. Ein paar code schnipsel wären toll!

Danke schonmal :)

Ausschnitt auf dem 18F4550

 
I2C_IDLE() //function checks the status of the bus. It checks either I2C bus is busy or free. is It completed the last operation successfully?


void I2C_IDLE()
{
  while ((SSPSTAT & 0x04) || (SSPCON2 & 0x1F));
}
I2C_Initialize_Master() //function enables master mode and generates clock frequency by uploading a value to the SSPADD register.
void I2C_Master_Init()
{
SSPCON = 0x28;  // enable I2C pins SCL and SDA for serial communication
SSPCON2 = 0x00; 
SSPSTAT = 0x00;  //slew rate enables for high speed control
SSPADD = ((_XTAL_FREQ/4)/I2C_BaudRate) - 1;
TRISC3 = 1;  //Set as a digital input 
TRISC4 = 1;  //Set as a digital input 
}
//This function should be called before using other functions.
void I2C_Start()
{
I2C_IDLE();
SSPCON2bits.SEN = 1;  // initial start condition on SDA line
}
//This function sends stops condition to end data transfer.
void I2C_Stop()
{
I2C_IDLE();
SSPCON2bits.PEN = 1; // Initiate Stop condition on SDA and SCL pins
}
//This function sends a  signal to a slave that the master wants to send more data. It will restart the data transfer.
void I2C_Restart()
{
I2C_IDLE();
SSPCON2bits.RSEN = 1; // Initiate Repeated Start condition on SDA and SCL pins.
}
//These two functions provide an ACK signal after sending a 7bit/10bit address or 8bit data.
void I2C_ACK(void)
{
  I2C_IDLE();
  SSPCON2bits.ACKDT = 0; //Acknowledge Data bit  
  SSPCON2bits.ACKEN = 1;  // Acknowledge Sequence Enable bit(
}
void I2C_NACK(void)
{
I2C_IDLE();
SSPCON2bits.ACKDT = 1; 
SSPCON2bits.ACKEN = 1; 
}
I2C_Write() //used to transmit address and data through the SDA wire.
// input parameter to this function can be a byte ( either address or data)
unsigned char I2C_Write(unsigned char Data)
{
I2C_IDLE();   // wait untill I2C_Bus of PIC18F4550 microcontroller becomes free 
SSPBUF = Data; // store data inside SSPBUF register of PIC18F4550 microcontroller
I2C_Wait();  
return ACKSTAT; //return status of data or address transmission
}
This I2C_Read_Byte() //routine reads a byte from the I2C_Bus and returns its value.
unsigned char I2C_Read_Byte(void)
{
SSPCON2bits.RCEN = 1; // Enable & Start Reception
while(!SSPIF); // Wait Until Completion
SSPIF = 0; // Clear The Interrupt Flag Bit
return SSPBUF; // Return The Received Byte
}

Example aus MPLapMCC

#ifndef I2C2_MASTER_EXAMPLE_H
#define I2C2_MASTER_EXAMPLE_H

#include <stdint.h>
#include <stdio.h>
#include "../i2c2_master.h"

uint8_t  I2C2_Read1ByteRegister(i2c2_address_t address, uint8_t reg);
uint16_t I2C2_Read2ByteRegister(i2c2_address_t address, uint8_t reg);
void I2C2_Write1ByteRegister(i2c2_address_t address, uint8_t reg, uint8_t data);
void I2C2_Write2ByteRegister(i2c2_address_t address, uint8_t reg, uint16_t data);
void I2C2_WriteNBytes(i2c2_address_t address, uint8_t *data, size_t len);
void I2C2_ReadNBytes(i2c2_address_t address, uint8_t *data, size_t len);
void I2C2_ReadDataBlock(i2c2_address_t address, uint8_t reg, uint8_t *data, size_t len);

#endif /* I2C2_MASTER_EXAMPLE_H */

Versuch der kombination

#include <stdint.h>

#if !defined BMP280_I2C
#define  BMP280_I2C2
#endif


#ifdef  BMP280_I2C2
#define BMP280_Start    I2C2_Start
#define BMP280_Write    I2C2_Wr
#define BMP280_Read     I2C2_Rd
#define BMP280_Stop     I2C2_Stop
#endif

#ifndef BMP280_I2C_ADDRESS
  #define BMP280_I2C_ADDRESS  0xEE
#endif

#define BMP280_CHIP_ID        0x58

#define BMP280_REG_DIG_T1     0x88
#define BMP280_REG_DIG_T2     0x8A
#define BMP280_REG_DIG_T3     0x8C

#define BMP280_REG_DIG_P1     0x8E
#define BMP280_REG_DIG_P2     0x90
#define BMP280_REG_DIG_P3     0x92
#define BMP280_REG_DIG_P4     0x94
#define BMP280_REG_DIG_P5     0x96
#define BMP280_REG_DIG_P6     0x98
#define BMP280_REG_DIG_P7     0x9A
#define BMP280_REG_DIG_P8     0x9C
#define BMP280_REG_DIG_P9     0x9E

#define BMP280_REG_CHIPID     0xD0
#define BMP280_REG_SOFTRESET  0xE0

#define BMP280_REG_STATUS     0xF3
#define BMP280_REG_CONTROL    0xF4
#define BMP280_REG_CONFIG     0xF5
#define BMP280_REG_PRESS_MSB  0xF7

int32_t adc_T, adc_P, t_fine;

//
void BMP280_Write8(uint8_t reg_addr, uint8_t _data);




//
// BMP280 sensor modes, register ctrl_meas mode[1:0]
typedef enum
{
  MODE_SLEEP  = 0x00,  // sleep mode
  MODE_FORCED = 0x01,  // forced mode
  MODE_NORMAL = 0x03   // normal mode
} BMP280_mode;

// oversampling setting. osrs_t[2:0], osrs_p[2:0]
typedef enum
{
  SAMPLING_SKIPPED = 0x00,  //skipped, output set to 0x80000
  SAMPLING_X1      = 0x01,  // oversampling x1
  SAMPLING_X2      = 0x02,  // oversampling x2
  SAMPLING_X4      = 0x03,  // oversampling x4
  SAMPLING_X8      = 0x04,  // oversampling x8
  SAMPLING_X16     = 0x05   // oversampling x16
} BMP280_sampling;

// filter setting filter[2:0]
typedef enum
{
  FILTER_OFF = 0x00,  // filter off
  FILTER_2   = 0x01,  // filter coefficient = 2
  FILTER_4   = 0x02,  // filter coefficient = 4
  FILTER_8   = 0x03,  // filter coefficient = 8
  FILTER_16  = 0x04   // filter coefficient = 16
} BMP280_filter;

// standby (inactive) time in ms (used in normal mode), t_sb[2:0]
typedef enum
{
  STANDBY_0_5   =  0x00,  // standby time = 0.5 ms
  STANDBY_62_5  =  0x01,  // standby time = 62.5 ms
  STANDBY_125   =  0x02,  // standby time = 125 ms
  STANDBY_250   =  0x03,  // standby time = 250 ms
  STANDBY_500   =  0x04,  // standby time = 500 ms
  STANDBY_1000  =  0x05,  // standby time = 1000 ms
  STANDBY_2000  =  0x06,  // standby time = 2000 ms
  STANDBY_4000  =  0x07   // standby time = 4000 ms
} standby_time;

struct
{
  uint16_t dig_T1;
  int16_t  dig_T2;
  int16_t  dig_T3;

  uint16_t dig_P1;
  int16_t  dig_P2;
  int16_t  dig_P3;
  int16_t  dig_P4;
  int16_t  dig_P5;
  int16_t  dig_P6;
  int16_t  dig_P7;
  int16_t  dig_P8;
  int16_t  dig_P9;
} BMP280_calib;

void I2C2_Write1ByteRegister(i2c2_address_t address, uint8_t reg, uint8_t data);
uint8_t  I2C2_Read1ByteRegister(i2c2_address_t address, uint8_t reg);

static i2c2_operations_t wr1RegCompleteHandler(void *ptr);
static i2c2_operations_t rd1RegCompleteHandler(void *ptr);



static i2c2_operations_t wr1RegCompleteHandler(void *ptr)
{
    I2C2_SetBuffer(ptr,1);
    I2C2_SetDataCompleteCallback(NULL,NULL);
    return I2C2_CONTINUE;
}

static i2c2_operations_t rd1RegCompleteHandler(void *ptr)
{
    I2C2_SetBuffer(ptr,1);
    I2C2_SetDataCompleteCallback(NULL,NULL);
    return I2C2_RESTART_READ;
}




// writes 1 byte '_data' to register 'reg_addr'
void BMP280_Write8(uint8_t reg_addr, uint8_t _data)
{
  while(!I2C2_Open(BMP280_I2C_ADDRESS)); // sit here until we get the bus..
  I2C2_SetDataCompleteCallback(wr1RegCompleteHandler,&_data);
  I2C2_SetBuffer(&reg_addr,1);
  I2C2_SetAddressNackCallback(NULL,NULL); //NACK polling?
  I2C2_MasterWrite();
  while(I2C2_BUSY == I2C2_Close()); // sit here until finished.
}

// reads 8 bits from register 'reg_addr'
uint8_t BMP280_Read8(uint8_t reg_addr)
{


    uint8_t ret = 0x00;
    
    while(!I2C2_Open(BMP280_I2C_ADDRESS)); // sit here until we get the bus..
    I2C2_SetDataCompleteCallback(rd1RegCompleteHandler,&ret);
    I2C2_SetBuffer(&reg_addr,1);
    I2C2_SetAddressNackCallback(NULL,NULL); //NACK polling?
    I2C2_MasterWrite();
    while(I2C2_BUSY == I2C2_Close()); // sit here until finished.
    
    return ret;


  /*uint8_t ret;

  BMP280_Start();
  BMP280_Write(BMP280_I2C_ADDRESS);
  BMP280_Write(reg_addr);
  BMP280_Start();
  BMP280_Write(BMP280_I2C_ADDRESS | 1);
  ret = BMP280_Read(0);
  BMP280_Stop();

  return ret;*/

MCC Master file

/**
  I2C2 Generated Driver File

  @Company
    Microchip Technology Inc.

  @File Name
    i2c2_master.c

  @Summary
    This is the generated driver implementation file for the I2C2 driver using PIC10 / PIC12 / PIC16 / PIC18 MCUs

  @Description
    This header file provides implementations for driver APIs for I2C2.
    Generation Information :
       ac Product Revision  :  PIC10 / PIC12 / PIC16 / PIC18 MCUs - 1.81.8
        Device            :  PIC18F45K42
        Driver Version    :  1.0.2
    The generated drivers are tested against the following:
        Compiler          :  XC8 2.36 and above or later
        MPLAB             :  MPLAB X 6.00
*/

/*
    (c) 2018 Microchip Technology Inc. and its subsidiaries. 
    
    Subject to your compliance with these terms, you may use Microchip software and any 
    derivatives exclusively with Microchip products. It is your responsibility to comply with third party 
    license terms applicable to your use of third party software (including open source software) that 
    may accompany Microchip software.
    
    THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER 
    EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY 
    IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS 
    FOR A PARTICULAR PURPOSE.
    
    IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, 
    INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND 
    WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP 
    HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO 
    THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL 
    CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT 
    OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS 
    SOFTWARE.
*/

#include "i2c2_master.h"
#include <xc.h>

// I2C2 STATES
typedef enum {
    I2C2_IDLE = 0,
    I2C2_SEND_ADR_READ,
    I2C2_SEND_ADR_WRITE,
    I2C2_TX,
    I2C2_RX,
    I2C2_TX_EMPTY,
    I2C2_RX_EMPTY,        
    I2C2_SEND_RESTART_READ,
    I2C2_SEND_RESTART_WRITE,
    I2C2_SEND_RESTART,
    I2C2_SEND_STOP,
    I2C2_RX_ACK,
    I2C2_TX_ACK,
    I2C2_RX_NACK_STOP,
    I2C2_RX_NACK_RESTART,
    I2C2_RESET,
    I2C2_ADDRESS_NACK,
    I2C2_BUS_COLLISION,
    I2C2_BUS_ERROR
} i2c2_fsm_states_t;

// I2C2 Event callBack List
typedef enum {
    I2C2_DATA_COMPLETE = 0,
    I2C2_WRITE_COLLISION,
    I2C2_ADDR_NACK,
    I2C2_DATA_NACK,
    I2C2_TIMEOUT,
    I2C2_NULL
} i2c2_callbackIndex_t;

// I2C2 Status Structure
typedef struct
{
    i2c2_callback_t callbackTable[6];
    void *callbackPayload[6];           //  each callBack can have a payload
    uint16_t time_out;                  // I2C2 Timeout Counter between I2C2 Events.
    uint16_t time_out_value;            // Reload value for the timeouts
    i2c2_address_t address;             // The I2C2 Address
    uint8_t *data_ptr;                  // pointer to a data buffer
    size_t data_length;                 // Bytes in the data buffer
    i2c2_fsm_states_t state;            // Driver State
    i2c2_error_t error;
    unsigned addressNackCheck:2;
    unsigned busy:1;
    unsigned inUse:1;
    unsigned bufferFree:1;

} i2c2_status_t;

static void I2C2_SetCallback(i2c2_callbackIndex_t idx, i2c2_callback_t cb, void *ptr);
static void I2C2_Poller(void);
static inline void I2C2_ClearInterruptFlags(void);
static inline void I2C2_MasterFsm(void);

/* I2C2 interfaces */
static inline bool I2C2_MasterOpen(void);
static inline void I2C2_MasterClose(void);    
static inline uint8_t I2C2_MasterGetRxData(void);
static inline void I2C2_MasterSendTxData(uint8_t data);
static inline void I2C2_MasterSetCounter(uint8_t counter);
static inline uint8_t I2C2_MasterGetCounter();
static inline void I2C2_MasterResetBus(void);
static inline void I2C2_MasterEnableRestart(void);
static inline void I2C2_MasterDisableRestart(void);
static inline void I2C2_MasterStop(void);
static inline bool I2C2_MasterIsNack(void);
static inline void I2C2_MasterSendAck(void);
static inline void I2C2_MasterSendNack(void);
static inline void I2C2_MasterClearBusCollision(void);
static inline bool I2C2_MasterIsRxBufFull(void);
static inline bool I2C2_MasterIsTxBufEmpty(void);
static inline bool I2C2_MasterIsStopFlagSet(void);
static inline bool I2C2_MasterIsCountFlagSet(void);
static inline bool I2C2_MasterIsNackFlagSet(void);
static inline void I2C2_MasterClearStopFlag(void);
static inline void I2C2_MasterClearCountFlag(void);
static inline void I2C2_MasterClearNackFlag(void);

/* Interrupt interfaces */
static inline void I2C2_MasterEnableIrq(void);
static inline bool I2C2_MasterIsIrqEnabled(void);
static inline void I2C2_MasterDisableIrq(void);
static inline void I2C2_MasterClearIrq(void);
static inline void I2C2_MasterWaitForEvent(void);

static i2c2_fsm_states_t I2C2_DO_IDLE(void);
static i2c2_fsm_states_t I2C2_DO_SEND_ADR_READ(void);
static i2c2_fsm_states_t I2C2_DO_SEND_ADR_WRITE(void);
static i2c2_fsm_states_t I2C2_DO_TX(void);
static i2c2_fsm_states_t I2C2_DO_RX(void);
static i2c2_fsm_states_t I2C2_DO_TX_EMPTY(void);
static i2c2_fsm_states_t I2C2_DO_RX_EMPTY(void);
static i2c2_fsm_states_t I2C2_DO_SEND_RESTART_READ(void);
static i2c2_fsm_states_t I2C2_DO_SEND_RESTART_WRITE(void);
static i2c2_fsm_states_t I2C2_DO_SEND_RESTART(void);
static i2c2_fsm_states_t I2C2_DO_SEND_STOP(void);
static i2c2_fsm_states_t I2C2_DO_RX_ACK(void);
static i2c2_fsm_states_t I2C2_DO_TX_ACK(void);
static i2c2_fsm_states_t I2C2_DO_RX_NACK_STOP(void);
static i2c2_fsm_states_t I2C2_DO_RX_NACK_RESTART(void);
static i2c2_fsm_states_t I2C2_DO_RESET(void);
static i2c2_fsm_states_t I2C2_DO_ADDRESS_NACK(void);
static i2c2_fsm_states_t I2C2_DO_BUS_COLLISION(void);
static i2c2_fsm_states_t I2C2_DO_BUS_ERROR(void);

typedef i2c2_fsm_states_t (*i2c2FsmHandler)(void);
const i2c2FsmHandler i2c2_fsmStateTable[] = {
    I2C2_DO_IDLE,
    I2C2_DO_SEND_ADR_READ,
    I2C2_DO_SEND_ADR_WRITE,
    I2C2_DO_TX,
    I2C2_DO_RX,
    I2C2_DO_TX_EMPTY,
    I2C2_DO_RX_EMPTY,
    I2C2_DO_SEND_RESTART_READ,
    I2C2_DO_SEND_RESTART_WRITE,
    I2C2_DO_SEND_RESTART,
    I2C2_DO_SEND_STOP,
    I2C2_DO_RX_ACK,
    I2C2_DO_TX_ACK,
    I2C2_DO_RX_NACK_STOP,
    I2C2_DO_RX_NACK_RESTART,
    I2C2_DO_RESET,
    I2C2_DO_ADDRESS_NACK,
    I2C2_DO_BUS_COLLISION,
    I2C2_DO_BUS_ERROR
};

i2c2_status_t I2C2_Status = {0};

void I2C2_Initialize()
{
    //EN disabled; RSEN disabled; S Cleared by hardware after Start; CSTR Enable clocking; MODE 7-bit address; 
    I2C2CON0 = 0x04;
    //ACKCNT Acknowledge; ACKDT Acknowledge; ACKSTAT ACK received; ACKT 0; RXO 0; TXU 0; CSD Clock Stretching enabled; 
    I2C2CON1 = 0x80;
    //ACNT disabled; GCEN disabled; FME disabled; ABD disabled; SDAHT 30 ns hold time; BFRET 8 I2C Clock pulses; 
    I2C2CON2 = 0x18;
    //CLK MFINTOSC; 
    I2C2CLK = 0x03;
    //CNTIF 0; ACKTIF 0; WRIF 0; ADRIF 0; PCIF 0; RSCIF 0; SCIF 0; 
    I2C2PIR = 0x00;
    //CNTIE disabled; ACKTIE disabled; WRIE disabled; ADRIE disabled; PCIE disabled; RSCIE disabled; SCIE disabled; 
    I2C2PIE = 0x00;
    //BTOIF No bus timout; BCLIF No bus collision detected; NACKIF No NACK/Error detected; BTOIE disabled; BCLIE disabled; NACKIE disabled; 
    I2C2ERR = 0x00;
    //Count register 
    I2C2CNT = 0xFF;
    return;
}

i2c2_error_t I2C2_Open(i2c2_address_t address)
{
    i2c2_error_t returnValue = I2C2_BUSY;
    
    if(!I2C2_Status.inUse)
    {
        I2C2_Status.address = address;
        I2C2_Status.busy = 0;
        I2C2_Status.inUse = 1;
        I2C2_Status.addressNackCheck = 0;
        I2C2_Status.state = I2C2_RESET;
        I2C2_Status.time_out_value = 500; // MCC should determine a reasonable starting value here.
        I2C2_Status.bufferFree = 1;

        // set all the call backs to a default of sending stop
        I2C2_Status.callbackTable[I2C2_DATA_COMPLETE]=I2C2_CallbackReturnStop;
        I2C2_Status.callbackPayload[I2C2_DATA_COMPLETE] = NULL;
        I2C2_Status.callbackTable[I2C2_WRITE_COLLISION]=I2C2_CallbackReturnStop;
        I2C2_Status.callbackPayload[I2C2_WRITE_COLLISION] = NULL;
        I2C2_Status.callbackTable[I2C2_ADDR_NACK]=I2C2_CallbackReturnStop;
        I2C2_Status.callbackPayload[I2C2_ADDR_NACK] = NULL;
        I2C2_Status.callbackTable[I2C2_DATA_NACK]=I2C2_CallbackReturnStop;
        I2C2_Status.callbackPayload[I2C2_DATA_NACK] = NULL;
        I2C2_Status.callbackTable[I2C2_TIMEOUT]=I2C2_CallbackReturnReset;
        I2C2_Status.callbackPayload[I2C2_TIMEOUT] = NULL;
        
        I2C2_MasterClearIrq();
        I2C2_MasterOpen();
        returnValue = I2C2_NOERR;
    }
    return returnValue;
}

i2c2_error_t I2C2_Close(void)
{
    i2c2_error_t returnValue = I2C2_BUSY;
    if(!I2C2_Status.busy)
    {
        I2C2_Status.inUse = 0;
        I2C2_Status.address = 0xff;
        I2C2_MasterClearIrq();
        I2C2_MasterDisableIrq();
        I2C2_MasterClose();
        returnValue = I2C2_Status.error;
    }
    return returnValue;
}

i2c2_error_t I2C2_MasterOperation(bool read)
{
    i2c2_error_t returnValue = I2C2_BUSY;
    if(!I2C2_Status.busy)
    {
        I2C2_Status.busy = true;
        returnValue = I2C2_NOERR;
        I2C2_MasterSetCounter((uint8_t) I2C2_Status.data_length);

        if(read)
        {
            I2C2_Status.state = I2C2_RX;
            I2C2_DO_SEND_ADR_READ();
        }
        else
        {
            I2C2_Status.state = I2C2_TX;
            I2C2_DO_SEND_ADR_WRITE();
        }
        I2C2_Poller();
    }
    return returnValue;
}

i2c2_error_t I2C2_MasterRead(void)
{
    return I2C2_MasterOperation(true);
}

i2c2_error_t I2C2_MasterWrite(void)
{
    return I2C2_MasterOperation(false);
}

void I2C2_SetTimeOut(uint8_t timeOutValue)
{
    I2C2_MasterDisableIrq();
    I2C2_Status.time_out_value = timeOutValue;
    I2C2_MasterEnableIrq();
}

void I2C2_SetBuffer(void *buffer, size_t bufferSize)
{
    if(I2C2_Status.bufferFree)
    {
        I2C2_Status.data_ptr = buffer;
        I2C2_Status.data_length = bufferSize;
        I2C2_Status.bufferFree = false;
    }
}

void I2C2_SetDataCompleteCallback(i2c2_callback_t cb, void *ptr)
{
    I2C2_SetCallback(I2C2_DATA_COMPLETE, cb, ptr);
}

void I2C2_SetWriteCollisionCallback(i2c2_callback_t cb, void *ptr)
{
    I2C2_SetCallback(I2C2_WRITE_COLLISION, cb, ptr);
}

void I2C2_SetAddressNackCallback(i2c2_callback_t cb, void *ptr)
{
    I2C2_SetCallback(I2C2_ADDR_NACK, cb, ptr);
}

void I2C2_SetDataNackCallback(i2c2_callback_t cb, void *ptr)
{
    I2C2_SetCallback(I2C2_DATA_NACK, cb, ptr);
}

void I2C2_SetTimeoutCallback(i2c2_callback_t cb, void *ptr)
{
    I2C2_SetCallback(I2C2_TIMEOUT, cb, ptr);
}

static void I2C2_SetCallback(i2c2_callbackIndex_t idx, i2c2_callback_t cb, void *ptr)
{
    if(cb)
    {
        I2C2_Status.callbackTable[idx] = cb;
        I2C2_Status.callbackPayload[idx] = ptr;
    }
    else
    {
        I2C2_Status.callbackTable[idx] = I2C2_CallbackReturnStop;
        I2C2_Status.callbackPayload[idx] = NULL;
    }
}

static void I2C2_Poller(void)
{
    while(I2C2_Status.busy)
    {
        I2C2_MasterWaitForEvent();
        I2C2_MasterFsm();
    }
}

static inline void I2C2_MasterFsm(void)
{
    I2C2_ClearInterruptFlags();

    if(I2C2_Status.addressNackCheck && I2C2_MasterIsNack())
    {
        I2C2_Status.state = I2C2_ADDRESS_NACK;
    }
    I2C2_Status.state = i2c2_fsmStateTable[I2C2_Status.state]();
}

static inline void I2C2_ClearInterruptFlags(void)
{
    if(I2C2_MasterIsCountFlagSet())
    {
        I2C2_MasterClearCountFlag();
    }
    else if(I2C2_MasterIsStopFlagSet())
    {
        I2C2_MasterClearStopFlag();
    }
    else if(I2C2_MasterIsNackFlagSet())
    {
        I2C2_MasterClearNackFlag();
    }
}

static i2c2_fsm_states_t I2C2_DO_IDLE(void)
{
    I2C2_Status.busy = false;
    I2C2_Status.error = I2C2_NOERR;
    return I2C2_RESET;
}

static i2c2_fsm_states_t I2C2_DO_SEND_ADR_READ(void)
{
    I2C2_Status.addressNackCheck = 2;
    if(I2C2_Status.data_length ==  1)
    {
        I2C2_DO_RX_EMPTY();
    }
    I2C2_MasterSendTxData((uint8_t) (I2C2_Status.address << 1 | 1));
    return I2C2_RX;
}

static i2c2_fsm_states_t I2C2_DO_SEND_ADR_WRITE(void)
{
    I2C2_Status.addressNackCheck = 2;
    I2C2_MasterSendTxData((uint8_t) (I2C2_Status.address << 1));
    return I2C2_TX;
}

static i2c2_fsm_states_t I2C2_DO_TX(void)
{
    if(I2C2_MasterIsNack())
    {
        switch(I2C2_Status.callbackTable[I2C2_DATA_NACK](I2C2_Status.callbackPayload[I2C2_DATA_NACK]))
        {
            case I2C2_RESTART_READ:
                return I2C2_DO_SEND_RESTART_READ();
            case I2C2_RESTART_WRITE:
                  return I2C2_DO_SEND_RESTART_WRITE();
            default:
            case I2C2_CONTINUE:
            case I2C2_STOP:
                return I2C2_IDLE;
        }
    }
    else if(I2C2_MasterIsTxBufEmpty())
    {
        if(I2C2_Status.addressNackCheck)
        {
            I2C2_Status.addressNackCheck--;
        }
        uint8_t dataTx = *I2C2_Status.data_ptr++;
        i2c2_fsm_states_t retFsmState = (--I2C2_Status.data_length)?I2C2_TX:I2C2_DO_TX_EMPTY();
        I2C2_MasterSendTxData(dataTx);
        return retFsmState;
    }
    else
    {
        return I2C2_TX;
    }
}

static i2c2_fsm_states_t I2C2_DO_RX(void)
{
    if(!I2C2_MasterIsRxBufFull())
    {
        return I2C2_RX;
    }
    if(I2C2_Status.addressNackCheck)
    {
        I2C2_Status.addressNackCheck--;
    }

    if(--I2C2_Status.data_length)
    {
        *I2C2_Status.data_ptr++ = I2C2_MasterGetRxData();
        return I2C2_RX;
    }
    else
    {
        i2c2_fsm_states_t retFsmState = I2C2_DO_RX_EMPTY();
        *I2C2_Status.data_ptr++ = I2C2_MasterGetRxData();
        return retFsmState;
    }
}

static i2c2_fsm_states_t I2C2_DO_TX_EMPTY(void)
{
    I2C2_Status.bufferFree = true;
    switch(I2C2_Status.callbackTable[I2C2_DATA_COMPLETE](I2C2_Status.callbackPayload[I2C2_DATA_COMPLETE]))
    {
        case I2C2_RESTART_READ:
            I2C2_MasterEnableRestart();
            return I2C2_SEND_RESTART_READ;
        case I2C2_CONTINUE:
            // Avoid the counter stop condition , Counter is incremented by 1
            I2C2_MasterSetCounter((uint8_t) I2C2_Status.data_length + 1);
            return I2C2_TX;
        default:
        case I2C2_STOP:
            I2C2_MasterDisableRestart();
            return I2C2_SEND_STOP;
    }
}

static i2c2_fsm_states_t I2C2_DO_RX_EMPTY(void)
{
    I2C2_Status.bufferFree = true;
    switch(I2C2_Status.callbackTable[I2C2_DATA_COMPLETE](I2C2_Status.callbackPayload[I2C2_DATA_COMPLETE]))
    {
        case I2C2_RESTART_WRITE:
            I2C2_MasterEnableRestart();
            return I2C2_SEND_RESTART_WRITE;
        case I2C2_RESTART_READ:
            I2C2_MasterEnableRestart();
            return I2C2_SEND_RESTART_READ;
        case I2C2_CONTINUE:
            // Avoid the counter stop condition , Counter is incremented by 1
            I2C2_MasterSetCounter((uint8_t) (I2C2_Status.data_length + 1));
            return I2C2_RX;
        default:
        case I2C2_STOP:
            if(I2C2_Status.state != I2C2_SEND_RESTART_READ)
            {
                I2C2_MasterDisableRestart();
            }
            return I2C2_RESET;
    }
}

static i2c2_fsm_states_t I2C2_DO_SEND_RESTART_READ(void)
{
    I2C2_MasterSetCounter((uint8_t) I2C2_Status.data_length);
    return I2C2_DO_SEND_ADR_READ();
}

static i2c2_fsm_states_t I2C2_DO_SEND_RESTART_WRITE(void)
{
    return I2C2_SEND_ADR_WRITE;
}


static i2c2_fsm_states_t I2C2_DO_SEND_RESTART(void)
{
    return I2C2_SEND_ADR_READ;
}

static i2c2_fsm_states_t I2C2_DO_SEND_STOP(void)
{
    I2C2_MasterStop();
    if(I2C2_MasterGetCounter())
    {
        I2C2_MasterSetCounter(0);
        I2C2_MasterSendTxData(0);
    }
    return I2C2_IDLE;
}

static i2c2_fsm_states_t I2C2_DO_RX_ACK(void)
{
    I2C2_MasterSendAck();
    return I2C2_RX;
}

static i2c2_fsm_states_t I2C2_DO_TX_ACK(void)
{
    I2C2_MasterSendAck();
    return I2C2_TX;
}

static i2c2_fsm_states_t I2C2_DO_RX_NACK_STOP(void)
{
    I2C2_MasterSendNack();
    I2C2_MasterStop();
    return I2C2_DO_IDLE();
}

static i2c2_fsm_states_t I2C2_DO_RX_NACK_RESTART(void)
{
    I2C2_MasterSendNack();
    return I2C2_SEND_RESTART;
}

static i2c2_fsm_states_t I2C2_DO_RESET(void)
{
    I2C2_MasterResetBus();
    I2C2_Status.busy = false;
    I2C2_Status.error = I2C2_NOERR;
    return I2C2_RESET;
}
static i2c2_fsm_states_t I2C2_DO_ADDRESS_NACK(void)
{
    I2C2_Status.addressNackCheck = 0;
    I2C2_Status.error = I2C2_FAIL;
    I2C2_Status.busy = false;
    switch(I2C2_Status.callbackTable[I2C2_ADDR_NACK](I2C2_Status.callbackPayload[I2C2_ADDR_NACK]))
    {
        case I2C2_RESTART_READ:
        case I2C2_RESTART_WRITE:
            return I2C2_DO_SEND_RESTART();
        default:
            return I2C2_RESET;
    }
}

static i2c2_fsm_states_t I2C2_DO_BUS_COLLISION(void)
{
    // Clear bus collision status flag
    I2C2_MasterClearIrq();

    I2C2_Status.error = I2C2_FAIL;
    switch (I2C2_Status.callbackTable[I2C2_WRITE_COLLISION](I2C2_Status.callbackPayload[I2C2_WRITE_COLLISION])) {
    case I2C2_RESTART_READ:
        return I2C2_DO_SEND_RESTART_READ();
    case I2C2_RESTART_WRITE:
        return I2C2_DO_SEND_RESTART_WRITE();
    default:
        return I2C2_DO_RESET();
    }
}

static i2c2_fsm_states_t I2C2_DO_BUS_ERROR(void)
{
    I2C2_MasterResetBus();
    I2C2_Status.busy  = false;
    I2C2_Status.error = I2C2_FAIL;
    return I2C2_RESET;
}

void I2C2_BusCollisionIsr(void)
{
    I2C2_MasterClearBusCollision();
    I2C2_Status.state = I2C2_RESET;
}

i2c2_operations_t I2C2_CallbackReturnStop(void *funPtr)
{
    return I2C2_STOP;
}

i2c2_operations_t I2C2_CallbackReturnReset(void *funPtr)
{
    return I2C2_RESET_LINK;
}

i2c2_operations_t I2C2_CallbackRestartWrite(void *funPtr)
{
    return I2C2_RESTART_WRITE;
}

i2c2_operations_t I2C2_CallbackRestartRead(void *funPtr)
{
    return I2C2_RESTART_READ;
}



/* I2C2 Register Level interfaces */
static inline bool I2C2_MasterOpen(void)
{
    if(!I2C2CON0bits.EN)
    {
        //CNTIF 0; ACKTIF 0; WRIF 0; ADRIF 0; PCIF 0; RSCIF 0; SCIF 0; 
        I2C2PIR = 0x00;
        //CNTIE disabled; ACKTIE disabled; WRIE disabled; ADRIE disabled; PCIE disabled; RSCIE disabled; SCIE disabled; 
        I2C2PIE = 0x00;
        //BTOIF No bus timout; BCLIF No bus collision detected; NACKIF No NACK/Error detected; BTOIE disabled; BCLIE disabled; NACKIE disabled; 
        I2C2ERR = 0x00;
        //Count register 
        I2C2CNT = 0xFF;
        //Clock PadReg Configuration
        RB1I2C   = 0x51;
        //Data PadReg Configuration
        RB2I2C   = 0x51;
        //Enable I2C2
        I2C2CON0bits.EN = 1;
        return true;
    }
    return false;
}

static inline void I2C2_MasterClose(void)
{
    //Disable I2C2
    I2C2CON0bits.EN = 0;
    //CNTIF 0; ACKTIF 0; WRIF 0; ADRIF 0; PCIF 0; RSCIF 0; SCIF 0; 
    I2C2PIR = 0x00;
    //Set Clear Buffer Flag
    I2C2STAT1bits.CLRBF = 1;
}

static inline uint8_t I2C2_MasterGetRxData(void)
{
    return I2C2RXB;
}

static inline void I2C2_MasterSendTxData(uint8_t data)
{
    I2C2TXB  = data;
}

static inline uint8_t I2C2_MasterGetCounter()
{
    return I2C2CNT;
}

static inline void I2C2_MasterSetCounter(uint8_t counter)
{
    I2C2CNT = counter;
}

static inline void I2C2_MasterResetBus(void)
{
    //Disable I2C2
    I2C2CON0bits.EN = 0;
    //Set Clear Buffer Flag
    I2C2STAT1bits.CLRBF = 1;
    //Enable I2C2
    I2C2CON0bits.EN = 1;
}

static inline void I2C2_MasterEnableRestart(void)
{
    //Enable I2C2 Restart
    I2C2CON0bits.RSEN = 1;
}

static inline void I2C2_MasterDisableRestart(void)
{
    //Disable I2C2 Restart
    I2C2CON0bits.RSEN = 0;
}

static inline void I2C2_MasterStop(void)
{
    //Clear Start Bit
    I2C2CON0bits.S = 0;
}

static inline bool I2C2_MasterIsNack(void)
{
    return I2C2CON1bits.ACKSTAT;
}

static inline void I2C2_MasterSendAck(void)
{
    I2C2CON1bits.ACKDT = 0;
}

static inline void I2C2_MasterSendNack(void)
{
    I2C2CON1bits.ACKDT = 1;
}

static inline void I2C2_MasterClearBusCollision(void)
{
    I2C2ERRbits.BCLIF = 0;
    I2C2ERRbits.BTOIF = 0;
    I2C2ERRbits.NACKIF = 0;
}

static inline bool I2C2_MasterIsRxBufFull(void)
{
    return I2C2STAT1bits.RXBF;
}

static inline bool I2C2_MasterIsTxBufEmpty(void)
{
    return I2C2STAT1bits.TXBE;
}

static inline bool I2C2_MasterIsStopFlagSet(void)
{
    return I2C2PIRbits.PCIF;
}

static inline bool I2C2_MasterIsCountFlagSet(void)
{
    return I2C2PIRbits.CNTIF;
}

static inline bool I2C2_MasterIsNackFlagSet(void)
{
    return I2C2ERRbits.NACKIF;
}

static inline void I2C2_MasterClearStopFlag(void)
{
    I2C2PIRbits.PCIF = 0;
}

static inline void I2C2_MasterClearCountFlag(void)
{
    I2C2PIRbits.CNTIF = 0;
}

static inline void I2C2_MasterClearNackFlag(void)
{
    I2C2ERRbits.NACKIF = 0;
}

static inline void I2C2_MasterEnableIrq(void)
{
    PIE6bits.I2C2IE    = 1;
    PIE6bits.I2C2EIE    = 1;
    PIE5bits.I2C2RXIE  = 1;
    PIE5bits.I2C2TXIE  = 1;

    I2C2PIEbits.PCIE = 1; 
    I2C2PIEbits.CNTIE = 1; 
    I2C2ERRbits.NACKIE = 1; 
}

static inline bool I2C2_MasterIsIrqEnabled(void)
{
    return (PIE5bits.I2C2RXIE && PIE5bits.I2C2TXIE && PIE6bits.I2C2IE);
}

static inline void I2C2_MasterDisableIrq(void)
{
    PIE6bits.I2C2IE    = 0;
    PIE6bits.I2C2EIE    = 0;
    PIE5bits.I2C2RXIE  = 0;
    PIE5bits.I2C2TXIE  = 0;
    I2C2PIEbits.SCIE = 0;
    I2C2PIEbits.PCIE = 0;
    I2C2PIEbits.CNTIE = 0;
    I2C2PIEbits.ACKTIE = 0;
    I2C2PIEbits.RSCIE = 0;
    I2C2ERRbits.BCLIE = 0;
    I2C2ERRbits.BTOIE = 0;
    I2C2ERRbits.NACKIE = 0;
}

static inline void I2C2_MasterClearIrq(void)
{
    I2C2PIR = 0x00;
}

static inline void I2C2_MasterWaitForEvent(void)
{
    while(1)
    {
        if(PIR5bits.I2C2TXIF)
        {    
            break;
        }
        if(PIR5bits.I2C2RXIF)
        {  
            break;
        } 
        if(I2C2PIRbits.PCIF)
        {
            break;
        } 
        if(I2C2PIRbits.CNTIF)
        {
            break;
        }
        if(I2C2ERRbits.NACKIF)
        {
            break;
        }
    }
}

[Monk (Gast)]

Du hast vergessen, zu beschreiben, wo es hakt. Hast du wenigstens einen 
logic analyzer? Wenn nicht, besorge dir einen (ab 10 Euro). Damit kannst 
du die Kommunikation untersuchen.

[Brom B. (schrori)]

Hallo, tatsächlich stehe ich einfach volle Lotte auf dem schlauch...

Ich hatte gerade die idee die funktionen welche mcc generiert zu nutzen.

Als erstes die chip adresse, dann die Adresse des registers im BMP280 
und am ende binär was ich schreiben möchte.

Aber wie time ich das?

Also sagen wir ich sende das ich lesen möchte. Muss ich dann einfach nur 
warten und sag ihm dannach so jetz lies dieses register aus?

Ich hab so einen treiber noch nie selbst geschrieben daher weiß ich 
einfach nicht wo ich anfangen soll und woe der ablauf ist.

Sorry wegen des codes
Grüße

[Bratmaxxe (Gast)]

Es gibt von Bosch eine C Bibliothek für den BMP280. Was du brauchst ist 
eine Wrappper-Funktion um deine eigentliche I2C Write und Read Funktion.

[Brom B. (schrori)]

Hallo Bratmaxe,

Das hat geholfen dann weiß ich schonmal was ich brauche.

Byte weise lesen und schreiben stellt MCC aus mplap bereit.

Was ist ein wrapper? :D

Ich bastel später mal was zusammen mit der bitte um Prüfung 😄

[Vorname N. (mcu32)]

Richard S. schrieb:
> Was ist ein wrapper? :D

Ein Wrapper ist eine Funktion, die um die eigentliche Driver Funktion 
"drum herum" geschrieben wird.
Weil verschiedene Controller unterschiedliche Bitadressen bzw. Treiber 
für die Verwendung der Peripherie wie I2C, SPI usw. besitzen, stellen 
Hersteller wie Bosch eine universelle API bereit, die dann noch 
entsprechend "gewrapped" werden muss.

Hier ein Beispiel auf einem STM32F103 mit der BME280 Bib von Bosch:

void BME280_Setup()
{
    //BME280
    bme280.intf_ptr = &dev_addr; //device address
    bme280.intf = BME280_I2C_INTF; //used interface (i2c)

    //Associate BME280 with I2C HAL
    //Typecast of I2C HAL receive/write function ptr to the suitable format for bme280 driver
    bme280.read =  (bme280_read_fptr_t)user_i2c_read;    //pointer to wrapper function for system specific i2c read
    bme280.write = (bme280_write_fptr_t)user_i2c_write;  //pointer to wrapper function for system specific i2c write
    bme280.delay_us = (bme280_delay_us_fptr_t)user_delay; //pointer to wrapper function for system specific delay
    bme280_status = bme280_init(&bme280);
}

int8_t user_i2c_read(uint8_t reg_addr, uint8_t *reg_data, uint32_t len)
{

    HAL_StatusTypeDef status = HAL_OK;

    //initial value is usually zero
  int32_t iError = BME280_INIT_VALUE;

  uint8_t tempbuff[I2C_BUFFER_LEN] = {BME280_INIT_VALUE};
  uint8_t index = BME280_INIT_VALUE;
  tempbuff[BME280_INIT_VALUE] = reg_addr;

  uint8_t trials = 3;
  uint8_t timeout = 20;

  //check if I2C is ready to use, use the generated i2c instance
  while (HAL_I2C_IsDeviceReady(&hi2c1, (uint16_t)(dev_addr<<1), trials, timeout) != HAL_OK) {}

    status = HAL_I2C_Mem_Read(&hi2c1,              // i2c handle
                  (uint16_t)(dev_addr<<1),      // i2c address, left aligned
                (uint16_t)reg_addr,        // register address
                (uint16_t)I2C_MEMADD_SIZE_8BIT,  // bme280 uses 8bit register addresses
                tempbuff,              // write returned data to this variable
                len,          // how many bytes to expect returned
                timeout);                // timeout

    if (status != HAL_OK)
    {
      // The BME280 API calls for 0 return value as a success, and -1 returned as failure
      iError = (-1);
    }
  for (index = BME280_INIT_VALUE; index < len; index++) {
    *(reg_data + index) = tempbuff[index];
  }

  return (int8_t)iError;
}

Einfach gesagt schreibst du eine Funktion, die beim Aufrufen auf die 
entsprechenden Funktionen der API zeigt.

In dem von mir geposteten Beispiel siehst du die Initialisierung der 
Wrapper und die Implementation der Usereigenen i2c_read Funktion.
Bei der Initialisierung lasse ich die Funktionen der Bosch API auf meine 
Wrapperfunktionen zeigen.

Hier noch der Link zur Bosch API:
https://github.com/BoschSensortec/BME280_driver

Ich hoffe es kam halbwegs rüber was ich meine :D

[Brom B. (schrori)]

Danke für die umfangreiche Antwort:)

Also ich habe das jetz so verstanden das der Wrapper die API Funktionen 
aufgreift, und controller spezifische Parameter ergänzt. Sodass eine 
neue Funktion entsteht die einfach einfach ist oder?

Also man bastelt sich seine funktion aus den Funktionen der API und 
speichert das dann als zb. BMPWRITE

oder?

[Vorname N. (mcu32)]

JA genau. Du lässt beim Aufruf der API Funktion die entsprechende 
Funktion deines Controllers aufrufen. In meinem Beispiel rufe ich mit 
der Bosch API über meine User Funktion die I2C Funktion der STM32 HAL 
auf.

bme280.read =  (bme280_read_fptr_t)user_i2c_read;//pointer to wrapper function for system specific i2c read

Die Funktion read vom struct bme280 zeigt mit dem Pointer 
bme280_read_ptr auf die UserFunktion i2c_read.

Du lässt die API Funktion also auf die entsprechenden Funktionen zeigen. 
Du kannst natürlich auch eine komplett eigene Funktion schreiben bei der 
du in die I2C Schnittstelle die entsprechenden Bytes für den Sensor 
schickst. Ich persönlich finde den Weg mit Wrappern allerdings elegante.

[Stefan F. (Gast)]

Offenbar hast du zu viele unbekannte Baustellen gleichzeitig.

Klar ist, dass du mit I²C Kommunizieren musst. Das beginnt mit dem 
Senden einer Slave Adresse und dem Einlesen des ACK im neunten 
Takt-Impuls. Programmiere das mal in einem neuen leeren(!) Projekt bis 
zu diesem Punkt.

Den Erfolg kannst du wunderbar ohne Sensor mit dem Logic Analyzer 
kontrollieren.

Lies dazu 
http://stefanfrings.de/mikrocontroller_buch/Einstieg%20in%20die%20Elektronik%20mit%20Mikrocontrollern%20-%20Band%202.pdf 
Kapitel 5.9 bis 5.9.4.

Wenn du soweit bist, schauen wir weiter.

Als nächstes käme dann:

- nach dem ACK 0..n Bytes zu senden und dann 0..n Bytes zu empfangen.
- das ganze in eine Funktion zu verpacken, die man so aufrufen kann:

/**
 * Perform an I²C transaction
 * which sends 0 or more data bytes, followed by receiving 0 or 
 * more data bytes.
 *
 * slave_addr     7 bit slave address
 * send_buffer    Buffer to send (may be 0 if not used)
 * send_size      Number of bytes to send
 * receive_buffer Buffer to receive (may be 0 if not used)
 * receive_size   Number of bytes to receive
 * returns        Number of received data bytes, or -1 if sending failed,
 *                for example did not receive an ACK.
 */
int i2c_communicate(
    uint8_t slave_addr,
    void* send_buffer, int send_size, 
    void* receive_buffer, int receive_size) {
   ...
}

Erst dann kommt der Punkt, wo man sich mit dem Sensor und seinen 
Registern befasst. Als erstes würde ich Register 0xD0 (chip id) 
auslesen.

uint8_t send[]={0xD0}; // Register "chip id"
uint8_t receive[1];    // Buffer to receive 1 Byte
i2c_communicate(0x76, send, 1, receive, 1);

Die Sache mit den beiden Puffern kommt dir jetzt vielleicht noch unnötig 
kompliziert vor, aber spätestens wenn du mehrere Bytes senden/empfangen 
musst wird das so sehr praktisch.

Danach schau mal was man sonst noch alles auslesen kann ohne vorher 
etwas zu initialisieren oder zu starten. Erst wenn du damit klar kommst, 
befasse dich mit den komplexeren Abläufen.

Die mir bekannten Bosch Sensoren sind alle sehr einfach zu benutzen und 
unmissverständlich dokumentiert. Eine fertige Library würde ich nur 
benutzen, wenn mir auf Anhieb klar ist, wie sie zu benutzen ist. 
Ansonsten lieber selbst neu schreiben.

Normalerweise rate ich davon ab, das Rad neu zu erfinden, aber in diesem 
Fall sehe ich das ausnahmsweise mal anders.

[Forist (Gast)]

Richard S. schrieb:
> Ausschnitt auf dem 18F4550
> ...

Soory, nach der 5ten Seite habe ich aufgehört zu lesen, war mir zu dumm 
mit der Scrollerei.

Wichtige Regeln - erst lesen, dann posten!
...
Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

[Brom B. (schrori)]

Also erstmal vielen Dank an MCU und Stefan ich denke das hat wird mir 
sehr weiterhelfen vorallem die genauen Erklärungen zu den code passagen!

@Forist ja ich weiß sorry 😅

Die ganze ausführliche Materie werde ich mir auf jedenfall noch zu 
gemüte führen zu anfang werde ich jedoch versuchen den sensor mit den 
Befehlen aus mcc (erfordert doe slave adresse, das register und die Bit 
Belegung) zu triggern und im anschluss das readout register auslesen.

Da mich das aber generell interessiert interessiert mich schon alles von 
grund auf.

Vorallem möchte ich auch irgendwann RS485 nutzen 😄 danke euch ich 
berichte!

[Wolfgang (Gast)]

Richard S. schrieb:
> Vorallem möchte ich auch irgendwann RS485 nutzen

Der BMP280 kann I2C und SPI. Mit RS485 weiß der nichts anzufangen.

[Brom B. (schrori)]

Das weiß ich es geht darum das Ergebnis der Messung weiterzuleiten :)

[BesserWisser (Gast)]

Richard S. schrieb:
> Das weiß ich es geht darum

Nachdem was du hier zeigst/fragst, weist du überhaupt nichts und bis 
umfangreich talent frei. Schlicht zu dämlich für dieses Hobby!

Wiederml das übliche Rumgesülze und Frage/Bitte an Dritte hins. macht 
doch mal schnell, dass was ich will/brauche aber nicht kann - zum 
kotzen!

[Brom B. (schrori)]

BesserWisser schrieb:
> Richard S. schrieb:
>> Das weiß ich es geht darum
>
> Nachdem was du hier zeigst/fragst, weist du überhaupt nichts und bis
> umfangreich talent frei. Schlicht zu dämlich für dieses Hobby!
>
> Wiederml das übliche Rumgesülze und Frage/Bitte an Dritte hins. macht
> doch mal schnell, dass was ich will/brauche aber nicht kann - zum
> kotzen!


Traurig das es immer diese leute gibt die nichts besseres zu tun als 
blöd daher zu reden. Den Namen hast du dir sehr gut ausgesucht denn 
keiner kann solche leiden. Trotzdem tust du mir leid  traurig wenn man 
so drauf ist.

Man lernt nunmal am besten an beispielen und in diesem fall wäre das 
nunmal schritt für schritt erklärt.

Danke an die anderen nochmal die sinnvolle Beiträge leisten. Ich hatte 
auch bereits nach büchern zu PICs gesucht aber wirklich fündig geworden 
bin ich dabei auch nicht. Die meisten haben 2 3 Beispiele ala lasst die 
LED blinken aber wrapping oder gar treiber erstellen für Protokolle habe 
ich  och keine gefunden. Wenn ihr da was habt gern her damit:).

@besserwisser von dir bitte nicht such dir lieber einen Therapeuten 
menschen die nichts besseres zu tun haben als andere anonym zu 
beleidigen haben meist eine psychische störung die man behandeln sollte 
:)

Schönen abend den meisten! :)

[Brom B. (schrori)]

Hallo hallöchen nochmal da bin ich wieder:)

Also ich habe einen Wrapper gebaut mithilfe der I2C Library aus MCC und 
dem C Treiber von Bosch, das ganze wird auch fehler frei kompiliert. 
(Kam noch nicht zum anschließen)

Nun ist mir aber aufgefallen das diese Protokolle insbesondere der Bosch 
treiber enorm viel Flash Speicher ziehen. Könntet Ihr mir eine 
Hilfestellung geben  diesen zu optimieren?

Macht es sinn ungenutzte Funktionen einfach zu löschen? Ich dachte immer 
der Compiler entfernt von haus aus alles was nicht genutzt wird.

Und dann habe ich noch beobachtet das Bei 99% Flashspeicher Belegung 
(wenn ich die Bosch Funktion nicht aufrufe bin ich bei 40% von 32k) der 
SPI clock in höheren Frequenzen nicht mehr arbeitet. Ich musste teils 
auf 500khz runter um ein Signal zu bekommen. Kann das wirklich zusammen 
hängen?

Mein RAM liegt bei 400/4000 bytes.

Bevor die Frage kommt, ich habe einen TFT Monitor am SPI und die Fonts / 
Logos sind in BMPHex. Wenn ich diese ausklammere fällt der 
Speicherbedarf enorm.

Kann man das auch effizienter gestalten? Wenn ja, wie?

Danke euch und viele Grüße :)

[Vorname N. (mcu32)]

Wie hast du den Sensor denn verdrahtet? "Flying Wire" oder schön 
verdrillte Leitungen mit Schirmung? Wie lang sind diese?
Zum Optimieren: Das einfachste ist natürlich ein (meist kommerzieller) 
Compiler, mit entsprechendem Optimierungslevel. Aber da muss man häufig 
aufpassen das nichts essentielles wegoptimiert wird :)
Ansonsten die allgemeinen Regeln, unnötige Schleifen vermeiden, kein 
unnötiges Beleg von Speicher den man nie braucht. Speicher von 
temporären Variablen nach Gebrauch wieder frei geben usw.

Für eine speichereffiziente Ansteuerung von Displays gabs hier im Forum 
mal irgendwo einen Artikel wenn ich mich richtig erinnere.

[Brom B. (schrori)]

Vorname N. schrieb:
> Wie hast du den Sensor denn verdrahtet? "Flying Wire" oder schön
> verdrillte Leitungen mit Schirmung? Wie lang sind diese?
> Zum Optimieren: Das einfachste ist natürlich ein (meist kommerzieller)
> Compiler, mit entsprechendem Optimierungslevel. Aber da muss man häufig
> aufpassen das nichts essentielles wegoptimiert wird :)
> Ansonsten die allgemeinen Regeln, unnötige Schleifen vermeiden, kein
> unnötiges Beleg von Speicher den man nie braucht. Speicher von
> temporären Variablen nach Gebrauch wieder frei geben usw.
>
> Für eine speichereffiziente Ansteuerung von Displays gabs hier im Forum
> mal irgendwo einen Artikel wenn ich mich richtig erinnere.



Hallo Vorname.N.,
Momentan ist alles noch auf dem Steckbrettmit jumperkabeln 20cm wenn die 
schaltung steht lasse ich eine Platine bestücken auf welcher der Sensor 
genauso verschaltet ist wie auf dem Shield.

Die Optimierungsstufe 2 Und 3 des xc8 kamen mit ascc nicht zurecht, als 
ich das entfernt hatte brachte Stufe 2 ca 5000byte und für stufe 3 
prognostiziert er mir 10000byte einsparung.

Bei mir hängt es wirklich am Flash speicher, wenn ich ein Bitmap nur 
einmal benötige (zb. BOOTlogo) und die Variable in der diese BMP als hex 
gespeichert wird auf zb 0 gesetzt wird (oder wie löscht man den speicher 
richtig?) Bevor der include des I2c und BMP kommt, spare ich mir dann 
wirklich Flash speicher? Und müssten schleifen nicht eigentlich gut 
sein? Denn am Arbeitsspeicher mangelts mir ja nicht sondern der Programm 
speicher ist zu gering. 😅

Nach der Display Geschichte werd ich mal suchen Danke!!

Achso und das SPI CLK problem konnte ich am oszi messen / sehen mit 
vollerem speicher konnte der hohe takt nicht mehr  gehalten werden.

[Vorname N. (mcu32)]

Wie hast du die Kommunikation implementiert? Polst du die Buffer oder 
machst du es Interruptgesteuert?

[Brom B. (schrori)]

Vorname N. schrieb:
> Wie hast du die Kommunikation implementiert? Polst du die Buffer oder
> machst du es Interruptgesteuert?


Interrupts habe ich keine hinterlegt soweit ich weiß. Ich habe lediglich 
die Read und Write kommandos des MCC in die Bosch samples an dem 
entsprechenden platzhalter eingefügt und die datentypen  bze so lange 
angepasst bis der compiler nicht mehr geneckert hat 😅

Also es wird ein Configurations byte gesendet und dannach wird der 
Ausgabe byte immer wieder abgefragt.

Beide geräte sowohl SPI TFT als auch I2C sensor sind 100% Slave und 
senden keine aktiven Signale

[Vorname N. (mcu32)]

Mh ok. Das könnte zumindest mal dein Problem mit SPI erklären. Wenn du 
sowas Polst kann es bei höherer Auslastung der CPU gut möglich sein dass 
irgendwann das Timing nicht mehr eingehalten wird.

Bei der restlichen Optimierung kann ich dir leider wenig helfen - ich 
kenne deinen Code nicht. Aber verstehe ich das richtig, dass du 
sämtliche Bildformate / Grafiken auf deinem µC hinterlegt hast?

Oh und Glückwunsch dass es zumindest in einem gewissen Bereich gut 
funktioniert :)

[Brom B. (schrori)]

Vorname N. schrieb:
> Mh ok. Das könnte zumindest mal dein Problem mit SPI erklären. Wenn du
> sowas Polst kann es bei höherer Auslastung der CPU gut möglich sein dass
> irgendwann das Timing nicht mehr eingehalten wird.
>
> Bei der restlichen Optimierung kann ich dir leider wenig helfen - ich
> kenne deinen Code nicht. Aber verstehe ich das richtig, dass du
> sämtliche Bildformate / Grafiken auf deinem µC hinterlegt hast?
>
> Oh und Glückwunsch dass es zumindest in einem gewissen Bereich gut
> funktioniert :)


Vielen Dank :D

Naja der Bildschirm ist ein ST7735 und reagiert einfach auf Signale die 
er empfängt. Er bekommt also pixel für pixel via spi gesendet.

Spi und I2c triggere ich aber nacheinander also nie beide parallel.

Spi kann den hohen takt sehr gut halten bis der Flashspeicher sich 
füllt.

Ob der Sensor wirklich macht was er soll erfahre ich erst wenn ich den 
levelshifter angebracht habe 😁

"Sämtliche bildformate und grafiken" sind in meinem Fall 1 Logo ca 
100x80px alt binär BMP in Hex, und 2 Fonts (A-Z a-z 0-9 und 
Sonderzeichen.

Ich habe das in eine eigene Header gepackt und dementsprechend ist es im 
Programmcode hinterlegt als Char.

Wie könnte ich es denn sonst noch speichern?
Ist ein Zusätzlicher speicherchip sehr aufwendig?

Der Code ist noch recht wüst im Grunde habe ich mich nach und nach an 
die Funktionen herangetastet die funktionen neu orientiert und dann 
weiterverarbeitet.

Vg

[Brom B. (schrori)]

Addr W2812 Rgbs steuere ich noch mit 1 2 Bitbanging schleifen aber das 
läuft alles für 2-3 for Geschichten sollte doch harmlos sein oder?

[Vorname N. (mcu32)]

Ich muss gestehen das ich mit "größeren" Images bisher nur mit TouchGFX 
o.ä. gearbeitet habe. Bei den Displays, die ich dafür verwendet habe ist 
ein separater Slot für eine microSD Karte eingebaut, Zugriff erfolgt 
durch den µC dann durch DMA.

[Brom B. (schrori)]

Vorname N. schrieb:
> Ich muss gestehen das ich mit "größeren" Images bisher nur mit TouchGFX
> o.ä. gearbeitet habe. Bei den Displays, die ich dafür verwendet habe ist
> ein separater Slot für eine microSD Karte eingebaut, Zugriff erfolgt
> durch den µC dann durch DMA.

Diese Möglichkeit habe ich eine MicroSd karte befindet sich ebenso am 
bildschirm und ist für späteres datenlogging ohnehin vorgesehen.
Mit DMA habe ich bisher 0 befasst ich weis aber das der uC das kann,

Könntedt du mir hier eine kurze Erklärung abgeben? Soweit ich weiß 
/dachte klappt das mit der SD Karte nur via spi 🤔

[Vorname N. (mcu32)]

Puh. Also ich bin da auch kein Experte darin, ich kann nur sagen dass du 
die Daten auf der Karte dann nicht per CPU "holst" sondern du diese 
quasi direkt per SPI buffern kannst. Das hat den Vorteil, dass die CPU 
währenddessen alles andere erledigen kann und die Übertragung deiner 
Bilddaten beispielswiese in Hardware implementiert abläuft.

Der Beispielcode den ich dir zum Thema Wrapper gepostet habe ist aus 
einem Projekt, das ich vor 2 Jahren mal angefangen habe - seit dem mache 
ich eigentlich nur noch Hardware und bin größtenteils raus aus dem Thema 
Embedded Software :D
Mein Wissen dazu ist also nicht mehr ganz so direkt verfügbar.

[Brom B. (schrori)]

Ok dann werd ich mal belesen :)

Aber zum generellen einbinden, würde ich sozusagen alles speichern und 
dann die ganzen benötigten Bitmaps (oder pixel hex wie immer das heisst) 
von der SD In den RAM buffern und diesen nach verwendung wieder 
freigeben richtig?

Wie genau lösche ich in C eine Variable so das der speicher wirklich 
woeder frei ist?

VG

[Brom B. (schrori)]

Bzw. Könnte ich den inhalt (zumindest die großen Bitmaps) als locale 
variable laden dann müsste nach abschluss der Speicher wieder frei sein 
richtig? Das klingt schonmal alles sehr super duper :D

Lässt sich mit DMA auch ein txt file auf die Sd schreiben? :)

[Stefan F. (Gast)]

Richard S. schrieb:
> Wie genau lösche ich in C eine Variable so das der speicher wirklich
> woeder frei ist?

Gar nicht.

Globale und statische Variablen sind immer da. Sie haben eine feste 
Adresse.

Lokale Variablen in Funktionen liegen auf dem Stack, welcher beim 
Verlassen der Funktion freigegeben wird.

Wenn du mit malloc() dynamischen Speicher im Heap belegst, gibst du ihn 
mit free() wieder frei.

[Brom B. (schrori)]

Stefan F. schrieb:
> Richard S. schrieb:
>> Wie genau lösche ich in C eine Variable so das der speicher wirklich
>> woeder frei ist?
>
> Gar nicht.
>
> Globale und statische Variablen sind immer da. Sie haben eine feste
> Adresse.
>
> Lokale Variablen in Funktionen liegen auf dem Stack, welcher beim
> Verlassen der Funktion freigegeben wird.
>
> Wenn du mit malloc() dynamischen Speicher im Heap belegst, gibst du ihn
> mit free() wieder frei.

Hi Steffen danke für die Antwort,
Wie kann ich mir das vorstellen? Erzeuge ich dann eine char Variable die 
bewusst im dynamischen speicher liegt?

Vg

[Stefan F. (Gast)]

Richard S. schrieb:
> Erzeuge ich dann eine char Variable die
> bewusst im dynamischen speicher liegt?

Es ist primitiver: Du reservierst eine gewisse Anzahl Bytes und bekommst 
einen Zeiger auf den Speicherbereich. Was du wie darin speicherst bleibt 
dir überlassen

https://www.c-howto.de/tutorial/arrays-felder/speicherverwaltung/

Prüfe aber vorher, ob malloc() von deiner C Bibliothek überhaupt 
unterstützt wird. Bei machen Mikrocontrollern muss man diese Funktion 
selbst implementieren.

[Brom B. (schrori)]

Verstehe aber der dynamische speicher ist dann trotzdem futsch...
Im falle der SD Karte könnte ich also zb. (Manuell) eine char mit länge 
500 erstellen und deren Wert immer wieder neu beschreiben.
Im grunde wäre das doch das gleiche oder?

Mit der Ausnahme das im falle der char jedes file die gleiche größe 
haben muss während es im dynamischen speicher nur die selbige anfangs 
adresse hat oder?

Hab icj das richtig verstanden?

[Stefan F. (Gast)]

Richard S. schrieb:
> Im grunde wäre das doch das gleiche oder?

Ja. Bei Mikrocontrollern macht es relativ selten Sinn, Speicher 
dynamisch zu belegen. Bei PC schon eher, weil man möglichst viel 
ungenutzten Speicher anderen Programmen überlassen will.

Richard S. schrieb:
> Mit der Ausnahme das im falle der char jedes file die gleiche größe
> haben muss während es im dynamischen speicher nur die selbige anfangs
> adresse hat oder?

Wenn dein Puffer z.B. 500 Bytes groß ist heißt das nicht, dass jede 
Datei ihn komplett mit 500 Bytes ausnutzen muss. Man kann darin auch 
kleinere Dateien ablegen, wenn du dir die tatsächliche Größe woanders 
(in einer int Variable) merkst.

[RS (Gast)]

Stefan F. schrieb:
> Wenn dein Puffer z.B. 500 Bytes groß ist heißt das nicht, dass jede
> Datei ihn komplett mit 500 Bytes ausnutzen muss. Man kann darin auch
> kleinere Dateien ablegen, wenn du dir die tatsächliche Größe woanders
> (in einer int Variable) merkst.

Beispielsweise dann so?

char puffer[500];
int Datenlänge = 300;
char Filler = "0";
for (int i = 0; i<500 - Datenlänge; i++)
{
Filler = Filler + "0"
}

puffer = "Irgendwas mit 300 bytes" + Filter;

... = Puffer[0:300];

das ist bestimmt 100000 mal umständlicher als es sein müsste xD

oder meinst du jetzt in der malloc() Methode?

Ich hab ursprünglich mit Python da ist das alles etwas lockerer :D


PS hat mich irgendwie nicht eingeloggt

[Bratmaxxe (Gast)]

Da würde ich dann doch lieber direkt mit malloc() arbeiten.
Die Idee bei C ist ja, dass du mit beispielswiese

uint16_t meineVarible

 einen Speicherbereich von 2 Byte reservierst, egal ob da nun 2 Byte 
rein kommt oder nicht.
Mit malloc() hingegen kannst du gezielt bytewise Speicher belegen.

[Brom B. (schrori)]

Bratmaxxe schrieb:
> Da würde ich dann doch lieber direkt mit malloc() arbeiten.
> Die Idee bei C ist ja, dass du mit beispielswiese

uint16_t 
> meineVarible

 einen Speicherbereich von 2 Byte reservierst, egal ob
> da nun 2 Byte rein kommt oder nicht.
> Mit malloc() hingegen kannst du gezielt bytewise Speicher belegen.


Das ist wieder ein typisches Beispiel warum ich foren so schätze das 
sind infos die normale bücher einfach nicht deutlich hergeben.

Kurzes update btw, ich bekomme zahlen aus dem BMP. Die bosch library hat 
nicht funktioniert daher habe ich komplett eigene Funktionen geschrieben 
welche die bits aktiv senden und empfangen.

Für meine zwecke genügt das vollkommen :)

Jetz muss ich das wirr warr nurnoch entwirren xD

[Duckundweg (Gast)]

an  BesserWisser (Gast)

wenn dir das zu blöde ist, dann sei' doch das nächstemal einfach still 
und blättere über diesen Thread hinweg.
Dieses Forum krankt leider unerträglich an diesen besch.. 
Möchtegern-Motzern

[Brom B. (schrori)]

@Duckundweg danke für die Deckung :)

So also ich kann ihn Configurieren Werte auslesen usw.

Nun stehe ich vor dem Problem das ich total wirre nonsens zahlen habe...

Hat MPLap die Möglichkeit Print befehle auszugeben?

Ich habe meinen Bildschirm bzw. Sprintf im verdacht.

[Bernd (Gast)]

Jetzt musst du nur noch dig_T1 bis dig_T3 und dig_P1 bis dig_P9 auslesen 
und abspeichern. Daraus und aus den aktuellen Messwerten kannst du dann 
Temperatur und Druck berechnen. Weist du wie das geht? Ansonsten habe 
ich hier ein PDF-Dokument, wo das beschrieben ist, auch ein Beispiel als 
C-Programm. Ich weiß nicht mehr, wo ich das runtergeladen habe, sonst 
würde ich dir den Link schicken. Anhängen darf ich es wohl nicht, aber 
ich könnte es dir per PN schicken.

Bernd

[Brom B. (schrori)]

Bernd schrieb:
> Jetzt musst du nur noch dig_T1 bis dig_T3 und dig_P1 bis dig_P9 auslesen
> und abspeichern. Daraus und aus den aktuellen Messwerten kannst du dann
> Temperatur und Druck berechnen. Weist du wie das geht? Ansonsten habe
> ich hier ein PDF-Dokument, wo das beschrieben ist, auch ein Beispiel als
> C-Programm. Ich weiß nicht mehr, wo ich das runtergeladen habe, sonst
> würde ich dir den Link schicken. Anhängen darf ich es wohl nicht, aber
> ich könnte es dir per PN schicken.
>
> Bernd
6

Hallo Bernd,

Danke für den Hinweis das habe ich bereits gemacht:) das Problem lag 
tatsächlich darin das mein Tft treiber keine Doubles verarbeiten kann. 
Ich habe diese nun als float abgespeichert und habe präzise und 
sinnhafte werte! :)

Vielen Dank an alle!!

Für den nächsten der dannach sucht, ich habe einfach die Befehle aus dem 
MCC example genommen und die register aus dem datenblatt so beschrieben 
wie es dort steht.

Im Nachhinein eigentlich total einfach die formatiererei mit den 
datentypen ist viel schlimmer :D

[Vorname N. (mcu32)]

Brom B. schrieb:
> Im Nachhinein eigentlich total einfach die formatiererei mit den
> datentypen ist viel schlimmer :D

Das stimmt allerdings. Oft ist es mangels guter Doku Rumprobiererei wie 
man casten muss :)

[Brom B. (schrori)]

Jetz muss ich trotzdem nochmal einhaken was DMA angeht, funktioniert das 
das ich via SPI und DMA aud eine microSD zugreife obwohl ich den selben 
SPI für den TFT nutze?

Eigentlich ja kein Problem durch CS aber DMA läufz ja im Hintergrund 
wenn ich das richtig verstanden habe

[Akira (akari222023)]

Hallo du kannst Daten in ein serial flash ic schreiben.

Wenn die Daten in dem ich sind, klammerst du den source Code hierfür 
aus.

SD Card Braucht Recht viel Speicher für fat32

[Monk (Gast)]

Brom B. schrieb:
> Nun stehe ich vor dem Problem das ich total wirre nonsens zahlen habe...

Deswegen hatte ich dir empfohlen, zuerst die Chip ID auslesen. Klappt 
das korrekt? Wenn nicht, funktioniert die Kommunikation schon in den 
Grundzügen nicht. Das würdest du dann auch mit dem Logic Analyzer sehen.

OK, in deinem Fall war die Ursache etwas anderes. Aber behalte das 
trotzdem mal im Hinterkopf.

Brom B. schrieb:
> Im Nachhinein eigentlich total einfach

Siehst du, die gleiche Erfahrung habe ich mit anderen Sensoren von Bosch 
gemacht. Deswegen hatte ich in deinem Fall so schnell empfohlen, es 
selbst zu programmieren anstatt die Bibliothek zu benutzen.

Brom B. schrieb:
> Jetz muss ich trotzdem nochmal einhaken was DMA angeht, funktioniert das
> das ich via SPI und DMA aud eine microSD zugreife obwohl ich den selben
> SPI für den TFT nutze?

Wenn du sicher stellst, dass die beiden Peripherien immer nur 
abwechselnd angesprochen werden sollte das gehen. Wer auf das Display 
zugreifen will muss halt warten, bis die Kommunikation mit der SD Karte 
abgeschlossen ist (oder umgekehrt).

[Brom B. (schrori)]

Steve van de Grens schrieb:
> Brom B. schrieb:
>> Nun stehe ich vor dem Problem das ich total wirre nonsens zahlen habe...
>
> Deswegen hatte ich dir empfohlen, zuerst die Chip ID auslesen. Klappt
> das korrekt? Wenn nicht, funktioniert die Kommunikation schon in den
> Grundzügen nicht. Das wirst du dann auch mit dem Logic Analyzer sehen.



Der Sesor funktioniert auch mit Anzeige die werte passen, ich hatte zu 
wenig speicher zum bitshiften reserviert.

Akira schrieb:
> Hallo du kannst Daten in ein serial flash ic schreiben.
> Wenn die Daten in dem ich sind, klammerst du den source Code hierfür aus

Eignet sich das für ein Logfile? Kann ich das später dann auslesen bei 
bedarf? Falls ja würde ich gerne mehr erfahren welches IC wäre zb 
geeignet?

[Brom B. (schrori)]

Vorname N. schrieb:
> Brom B. schrieb:
>> Im Nachhinein eigentlich total einfach die formatiererei mit den
>> datentypen ist viel schlimmer :D
>
> Das stimmt allerdings. Oft ist es mangels guter Doku Rumprobiererei wie
> man casten muss :)

Steve van de Grens schrieb:
> Deswegen hatte ich dir empfohlen, zuerst die Chip ID auslesen. Klappt
> das korrekt? Wenn nicht, funktioniert die Kommunikation schon in den
> Grundzügen nicht. Das würdest du dann auch mit dem Logic Analyzer sehen.
> OK, in deinem Fall war die Ursache etwas anderes. Aber behalte das
> trotzdem mal im Hinterkopf.

Ist bestimmt generell gut für den code zu prüfen ob alles geht um 
aufhänger zu meiden :)

Steve van de Grens schrieb:
> Siehst du, die gleiche Erfahrung habe ich mit anderen Sensoren von Bosch
> gemacht. Deswegen hatte ich in deinem Fall so schnell empfohlen, es
> selbst zu programmieren anstatt die Bibliothek zu benutzen.


Ja jetzt weiß ich was du meintest xD totsl simpel eigentlich:D

Steve van de Grens schrieb:
> Wenn du sicher stellst, dass die beiden Peripherien immer nur
> abwechselnd angesprochen werden sollte das gehen. Wer auf das Display
> zugreifen will muss halt warten, bis die Kommunikation mit der SD Karte
> abgeschlossen ist (oder umgekehrt).



So war das ursprünglich auch gedacht.
Allerdings läuft ja DMA Permanent im Hintergrund bzw immer wenn ich es 
aufrufe. Die Bildschirm Aktualisierung dauert über SPI auch immer ein 
weilchen im Gegensatz zu den restlichen abläufen. Wenn ich dann noch 
warten muss bis spi von der Karte frei ist... wäre es nicht möglich 
ssgen wir die Anzahl der Messungen als doublelong im eeprom oder so zu 
speichern und diese bei bedarf mit dem pickit auszulesen?

Vg

[Monk (Gast)]

Brom B. schrieb:
> wäre es nicht möglich
> ssgen wir die Anzahl der Messungen als doublelong im eeprom oder so zu
> speichern und diese bei bedarf mit dem pickit auszulesen?

Ich verstehe die Frage nicht, insbesondere wie damit Zugriffskonflikte 
auf dem Bus vermieden werden könnten.

Willst du die Ergebnisse der Messung im EEProm speichern? Bedenke das 
man das EEprom nicht unbegrenzt oft beschrieben kann. Ich kenne PIC 
nicht, aber ich gehe mal davon aus, dass man das EEprom über den 
Programmieradapter nicht im laufenden Betrieb auslesen kann.

Bin jetzt nicht sicher, ob deine Frage so gemeint war.

[Brom B. (schrori)]

Steve van de Grens schrieb:
> Brom B. schrieb:
>> wäre es nicht möglich
>> ssgen wir die Anzahl der Messungen als doublelong im eeprom oder so zu
>> speichern und diese bei bedarf mit dem pickit auszulesen?
>
> Ich verstehe die Frage nicht, insbesondere wie damit Zugriffskonflikte
> auf dem Bus vermieden werden könnten.
>
> Willst du die Ergebnisse der Messung im EEProm speichern? Bedenke das
> man das EEprom nicht unbegrenzt oft beschrieben kann. Ich kenne PIC
> nicht, aber ich gehe mal davon aus, dass man das EEprom über den
> Programmieradapter nicht im laufenden Betrieb auslesen kann.
>
> Bin jetzt nicht sicher, ob deine Frage so gemeint war.

Im Grunde möchte ich daten speichern zb. Anzahl der Messungen über die 
zeit etc. Am liebsten als txt. Wenn ich das ganze dann abstecke möchte 
ich es auslesen.

[Monk (Gast)]

Brom B. schrieb:
> Im Grunde möchte ich daten speichern zb. Anzahl der Messungen über die
> zeit etc. Am liebsten als txt. Wenn ich das ganze dann abstecke möchte
> ich es auslesen.

OK. Dann rechne dir aus wie lange das EEPROM halten wird. Ein "Wear 
Levelling" Algorithmus kann helfen, die Lebensdauer des EEPROM erheblich 
zu erhöhen.

Alternativ würde sich anbieten, anstelle des PIC einen ESP8266 zu 
verwenden und die Messwerte per WLAN an einen Webserver oder MQTT Broker 
zu senden, der sie dann speichert. Dann brauchst du in deinem 
Mikrocontroller keine Uhr.