i2c.h

Go to the documentation of this file.

/*
 * Copyright (C) 2010-2012 The Paparazzi Team
 *
 * This file is part of paparazzi.
 *
 * paparazzi is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * paparazzi is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with paparazzi; see the file COPYING.  If not, write to
 * the Free Software Foundation, 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 */
 
#ifndef MCU_PERIPH_I2C_H
#define MCU_PERIPH_I2C_H
 
#include "std.h"
 
#include "mcu_periph/i2c_arch.h"
#include "modules/core/threads.h"
 
enum I2CTransactionType {
  I2CTransTx,   
  I2CTransRx,   
  I2CTransTxRx  
};
enum I2CTransactionType {…};
 
enum I2CTransactionStatus {
  I2CTransPending,  
  I2CTransRunning,  
  I2CTransSuccess,  
  I2CTransFailed,   
  I2CTransDone      
};
enum I2CTransactionStatus {…};
 
enum I2CStatus {
  I2CIdle,
  I2CStartRequested,
  I2CAddrWrSent,
  I2CAddrRdSent,
  I2CSendingByte,
  /*  I2CSendingLastByte, */
  I2CReadingByte,
  I2CReadingLastByte,
  I2CStopRequested,
  I2CRestartRequested,
  I2CComplete,
  I2CFailed
};
enum I2CStatus {…};
 
#ifndef I2C_BUF_LEN
#define I2C_BUF_LEN 32
#endif
 
struct i2c_transaction {
  enum I2CTransactionType type;
 
  uint8_t  slave_addr;
 
  uint16_t len_r;
 
  uint8_t  len_w;
 
  volatile uint8_t  buf[I2C_BUF_LEN];
 
  volatile enum I2CTransactionStatus status;
 
  pprz_bsem_t bsem;
};
struct i2c_transaction {…};
 
#ifndef I2C_TRANSACTION_QUEUE_LEN
#define I2C_TRANSACTION_QUEUE_LEN 8
#endif
 
struct i2c_periph;
typedef bool i2c_idle_fn_t(struct i2c_periph *p);
typedef bool i2c_submit_fn_t(struct i2c_periph *p, struct i2c_transaction *t);
typedef void i2c_setbitrate_fn_t(struct i2c_periph *p, int bitrate);
typedef void i2c_spin_fn_t(struct i2c_periph *p);  // To update peripherals within tight loops, e.g. the blocking functions. Leave NULL if not required.
 
struct i2c_periph {
  /* architecture-specific functions */
  i2c_idle_fn_t *idle;
  i2c_submit_fn_t *submit;
  i2c_setbitrate_fn_t *setbitrate;
  i2c_spin_fn_t *spin;
  /* circular buffer holding transactions */
  struct i2c_transaction *trans[I2C_TRANSACTION_QUEUE_LEN];
  uint8_t trans_insert_idx;
  uint8_t trans_extract_idx;
  /* internal state of the peripheral */
  volatile enum I2CStatus status;
  volatile uint8_t idx_buf;
  void *reg_addr;
  void *init_struct;
  struct i2c_errors *errors;
  volatile int16_t watchdog;
};
struct i2c_periph {…};
 
struct i2c_errors {
  volatile uint16_t wd_reset_cnt;
  volatile uint16_t queue_full_cnt;
  volatile uint16_t ack_fail_cnt;
  volatile uint16_t miss_start_stop_cnt;
  volatile uint16_t arb_lost_cnt;
  volatile uint16_t over_under_cnt;
  volatile uint16_t pec_recep_cnt;
  volatile uint16_t timeout_tlow_cnt;
  volatile uint16_t smbus_alert_cnt;
  volatile uint16_t unexpected_event_cnt;
  volatile uint32_t last_unexpected_event;
  volatile uint32_t er_irq_cnt;
};
struct i2c_errors {…};
 
 
#define ZEROS_ERR_COUNTER(_i2c_err) {     \
    _i2c_err.wd_reset_cnt = 0;            \
    _i2c_err.queue_full_cnt = 0;          \
    _i2c_err.ack_fail_cnt = 0;            \
    _i2c_err.miss_start_stop_cnt = 0;     \
    _i2c_err.arb_lost_cnt = 0;            \
    _i2c_err.over_under_cnt = 0;          \
    _i2c_err.pec_recep_cnt = 0;           \
    _i2c_err.timeout_tlow_cnt = 0;        \
    _i2c_err.smbus_alert_cnt = 0;         \
    _i2c_err.unexpected_event_cnt = 0;    \
    _i2c_err.last_unexpected_event = 0;   \
    _i2c_err.er_irq_cnt = 0;              \
  }
#define ZEROS_ERR_COUNTER(_i2c_err) {     \ …
 
 
#if USE_I2C0
 
extern struct i2c_periph i2c0;
extern void i2c0_init(void);
 
#endif /* USE_I2C0 */
 
 
#if USE_I2C1
 
extern struct i2c_periph i2c1;
extern void i2c1_init(void);
 
#endif /* USE_I2C1 */
 
 
#if USE_I2C2
 
extern struct i2c_periph i2c2;
extern void i2c2_init(void);
 
#endif /* USE_I2C2 */
 
 
#if USE_I2C3
 
extern struct i2c_periph i2c3;
extern void i2c3_init(void);
 
#endif /* USE_I2C3 */
 
 
#if USE_I2C4
 
extern struct i2c_periph i2c4;
extern void i2c4_init(void);
 
#endif /* USE_I2C4 */
 
 
#if USE_SOFTI2C0
extern struct i2c_periph softi2c0;
extern void softi2c0_init(void);
#endif /* USE_SOFTI2C0 */
 
 
#if USE_SOFTI2C1
extern struct i2c_periph softi2c1;
extern void softi2c1_init(void);
#endif /* USE_SOFTI2C1 */
 
 
extern void   i2c_init(struct i2c_periph *p);
 
static inline bool i2c_idle(struct i2c_periph *p) {
  return p->idle(p);
}
static inline bool i2c_idle(struct i2c_periph *p) {…}
 
static inline bool i2c_submit(struct i2c_periph *p, struct i2c_transaction *t) {
  return p->submit(p, t);
}
static inline bool i2c_submit(struct i2c_periph *p, struct i2c_transaction *t) {…}
 
static inline void   i2c_setbitrate(struct i2c_periph *p, int bitrate) {
  p->setbitrate(p, bitrate);
}
static inline void   i2c_setbitrate(struct i2c_periph *p, int bitrate) {…}
 
extern void   i2c_event(void);
 
/*
 * Convenience functions.
 * Usually these are preferred over i2c_submit,
 * as they explicitly set the transaction type again.
 *
 * Return FALSE if submitting the transaction failed.
 */
extern bool i2c_transmit(struct i2c_periph *p, struct i2c_transaction *t,
                         uint8_t s_addr, uint8_t len);
 
extern bool i2c_receive(struct i2c_periph *p, struct i2c_transaction *t,
                        uint8_t s_addr, uint16_t len);
 
extern bool i2c_transceive(struct i2c_periph *p, struct i2c_transaction *t,
                           uint8_t s_addr, uint8_t len_w, uint16_t len_r);
 
enum I2CTransactionStatus i2c_blocking_transmit(struct i2c_periph *p, struct i2c_transaction *t,
                           uint8_t s_addr, uint8_t len, float timeout);
 
enum I2CTransactionStatus i2c_blocking_receive(struct i2c_periph *p, struct i2c_transaction *t,
                          uint8_t s_addr, uint16_t len, float timeout);
 
enum I2CTransactionStatus i2c_blocking_transceive(struct i2c_periph *p, struct i2c_transaction *t,
                             uint8_t s_addr, uint8_t len_w, uint16_t len_r, float timeout);
#endif /* I2C_H */