main.c
[syntax=c]#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <math.h> //include libm
#include "mkuart/mkuart.h"
#include "i2c_prycon/i2c_prycon.h"
#define MPU6050_RA_WHO_AM_I 0x75
#define MPU6050_ADDR (0x68 <<1)
#define LED (1<<PB0)
#define LED_ON PORTB |= LED;
#define LED_OFF PORTB &= ~LED;
#define LED_TOG PORTB ^= LED;
typedef enum
{
TWI_IDLE = 0,
TWI_REQUEST_REGISTER = 1,
TWI_REQUEST_DATA = 2,
TWI_READ_DATA_FROM_BUFFER = 3,
TWI_SEND_DATA = 4,
} twiStateType;
void brak_miejsca_na_znaki_TX()
{
LED_ON;
}
int MPU6050_Test_I2C()
{
static twiStateType twiState = TWI_REQUEST_REGISTER;
if(i2cGetState()) return 0;
if(twiState == TWI_IDLE)
{
twiState = TWI_REQUEST_REGISTER;
return 1;
}
if(twiState == TWI_REQUEST_REGISTER)
{
//! send I2C data to a device on the bus
unsigned char dataOUT[1];
dataOUT[0] = MPU6050_RA_WHO_AM_I;
i2cMasterSend(MPU6050_ADDR, 1, dataOUT);
twiState = TWI_REQUEST_DATA;
}
else if(twiState == TWI_REQUEST_DATA)
{
//! receive I2C data from a device on the bu
i2cMasterReceive(MPU6050_ADDR, 1);
twiState = TWI_READ_DATA_FROM_BUFFER;
}
else if(twiState == TWI_READ_DATA_FROM_BUFFER)
{
static char itmp[10];
unsigned char dataIN[1];
i2cMasterReceiveBuffer(1, dataIN);
uart_puts("MPU6050 Address: 0x");
ltoa(dataIN[0], itmp, 16);
uart_puts(itmp);
uart_puts("\r\n");
twiState = TWI_IDLE;
}
return 0;
}
int main(void) {
USART_Init( __UBRR );
sei();
i2cInit();
uart_puts("Poczatek odczytu\r\n");
while(1)
{
if(MPU6050_Test_I2C()) _delay_ms(3000);
}
}[/syntax]
i2c_prycon.h
[syntax=c]/*! \file i2c.h \brief I2C interface using AVR Two-Wire Interface (TWI) hardware. */
//*****************************************************************************
//
// File Name: 'i2c.h'
// Title: I2C interface using AVR Two-Wire Interface (TWI) hardware
// Author: Pascal Stang - Copyright (C) 2002-2003
// Created: 2002.06.25
// Revised: 2003.03.03
// Version: 0.9
// Target MCU: Atmel AVR series
// Editor Tabs: 4
//
///\ingroup driver_avr
/// \defgroup i2c I2C Serial Interface Function Library (i2c.c)
/// \code #include "i2c.h" \endcode
/// \par Overview
///This library provides the high-level functions needed to use the I2C
///serial interface supported by the hardware of several AVR processors.
/// The library is functional but has not been exhaustively tested yet and is
/// still expanding. Thanks to the standardization of the I2C protocol and
///register access, the send and receive commands are everything you need to
/// talk to thousands of different I2C devices including: EEPROMS, Flash memory,
/// MP3 players, A/D and D/A converters, electronic potentiometers, etc.
///
/// \par About I2C
///I2C (pronounced "eye-squared-see") is a two-wire bidirectional
///network designed for easy transfer of information between a wide variety
///of intelligent devices. Many of the Atmel AVR series processors have
///hardware support for transmitting and receiving using an I2C-type bus.
///In addition to the AVRs, there are thousands of other parts made by
///manufacturers like Philips, Maxim, National, TI, etc that use I2C as
///their primary means of communication and control. Common device types
///are A/D & D/A converters, temp sensors, intelligent battery monitors,
///MP3 decoder chips, EEPROM chips, multiplexing switches, etc.
///
///I2C uses only two wires (SDA and SCL) to communicate bidirectionally
///between devices. I2C is a multidrop network, meaning that you can have
///several devices on a single bus. Because I2C uses a 7-bit number to
///identify which device it wants to talk to, you cannot have more than
///127 devices on a single bus.
///
///I2C ordinarily requires two 4.7K pull-up resistors to power (one each on
///SDA and SCL), but for small numbers of devices (maybe 1-4), it is enough
///to activate the internal pull-up resistors in the AVR processor. To do
///this, set the port pins, which correspond to the I2C pins SDA/SCL, high.
///For example, on the mega163, sbi(PORTC, 0); sbi(PORTC, 1);.
///
///For complete information about I2C, see the Philips Semiconductor
///website. They created I2C and have the largest family of devices that
///work with I2C.
///
/// \Note: Many manufacturers market I2C bus devices under a different or generic
///bus name like "Two-Wire Interface". This is because Philips still holds
///"I2C" as a trademark. For example, SMBus and SMBus devices are hardware
///compatible and closely related to I2C. They can be directly connected
///to an I2C bus along with other I2C devices are are generally accessed in
///the same way as I2C devices. SMBus is often found on modern motherboards
///for temp sensing and other low-level control tasks.
//
// This code is distributed under the GNU Public License
//which can be found at http://www.gnu.org/licenses/gpl.txt
//
//*****************************************************************************
#ifndef I2C_H
#define I2C_H
#include "global.h"
// include project-specific configuration
#include "i2cconf.h"
// TWSR values (not bits)
// (taken from avr-libc twi.h - thank you Marek Michalkiewicz)
// Master
#define TW_START0x08
#define TW_REP_START0x10
// Master Transmitter
#define TW_MT_SLA_ACK0x18
#define TW_MT_SLA_NACK0x20
#define TW_MT_DATA_ACK0x28
#define TW_MT_DATA_NACK0x30
#define TW_MT_ARB_LOST0x38
// Master Receiver
#define TW_MR_ARB_LOST0x38
#define TW_MR_SLA_ACK0x40
#define TW_MR_SLA_NACK0x48
#define TW_MR_DATA_ACK0x50
#define TW_MR_DATA_NACK0x58
// Slave Transmitter
#define TW_ST_SLA_ACK0xA8
#define TW_ST_ARB_LOST_SLA_ACK0xB0
#define TW_ST_DATA_ACK0xB8
#define TW_ST_DATA_NACK0xC0
#define TW_ST_LAST_DATA0xC8
// Slave Receiver
#define TW_SR_SLA_ACK0x60
#define TW_SR_ARB_LOST_SLA_ACK0x68
#define TW_SR_GCALL_ACK0x70
#define TW_SR_ARB_LOST_GCALL_ACK0x78
#define TW_SR_DATA_ACK0x80
#define TW_SR_DATA_NACK0x88
#define TW_SR_GCALL_DATA_ACK0x90
#define TW_SR_GCALL_DATA_NACK0x98
#define TW_SR_STOP0xA0
// Misc
#define TW_NO_INFO0xF8
#define TW_BUS_ERROR0x00
// defines and constants
#define TWCR_CMD_MASK0x0F
#define TWSR_STATUS_MASK0xF8
// return values
#define I2C_OK0x00
#define I2C_ERROR_NODEV0x01
// types
typedef enum
{
I2C_IDLE = 0, I2C_BUSY = 1,
I2C_MASTER_TX = 2, I2C_MASTER_RX = 3,
I2C_SLAVE_TX = 4, I2C_SLAVE_RX = 5
} eI2cStateType;
// functions
//! Initialize I2C (TWI) interface
void i2cInit(void);
//! Set the I2C transaction bitrate (in KHz)
void i2cSetBitrate(u16 bitrateKHz);
// I2C setup and configurations commands
//! Set the local (AVR processor's) I2C device address
void i2cSetLocalDeviceAddr(u08 deviceAddr, u08 genCallEn);
//! Set the user function which handles receiving (incoming) data as a slave
void i2cSetSlaveReceiveHandler(void (*i2cSlaveRx_func)(u08 receiveDataLength, u08* recieveData));
//! Set the user function which handles transmitting (outgoing) data as a slave
void i2cSetSlaveTransmitHandler(u08 (*i2cSlaveTx_func)(u08 transmitDataLengthMax, u08* transmitData));
// Low-level I2C transaction commands
//! Send an I2C start condition in Master mode
void i2cSendStart(void);
//! Send an I2C stop condition in Master mode
void i2cSendStop(void);
//! Wait for current I2C operation to complete
void i2cWaitForComplete(void);
//! Send an (address|R/W) combination or a data byte over I2C
void i2cSendByte(u08 data);
//! Receive a data byte over I2C
// ackFlag = TRUE if recevied data should be ACK'ed
// ackFlag = FALSE if recevied data should be NACK'ed
void i2cReceiveByte(u08 ackFlag);
//! Pick up the data that was received with i2cReceiveByte()
u08 i2cGetReceivedByte(void);
//! Get current I2c bus status from TWSR
u08 i2cGetStatus(void);
// high-level I2C transaction commands
//! send I2C data to a device on the bus
void i2cMasterSend(u08 deviceAddr, u08 length, u08 *data);
//! receive I2C data from a device on the bus
void i2cMasterReceive(u08 deviceAddr, u08 length);
//! receive I2C data from buffer
void i2cMasterReceiveBuffer(u08 length, u08* data);
//! send I2C data to a device on the bus (non-interrupt based)
u08 i2cMasterSendNI(u08 deviceAddr, u08 length, u08* data);
//! receive I2C data from a device on the bus (non-interrupt based)
u08 i2cMasterReceiveNI(u08 deviceAddr, u08 length, u08 *data);
//! Get the current high-level state of the I2C interface
eI2cStateType i2cGetState(void);
#endif[/syntax]
i2c_prycon.c
[syntax=c]/*! \file i2c.c \brief I2C interface using AVR Two-Wire Interface (TWI) hardware. */
//*****************************************************************************
//
// File Name: 'i2c.c'
// Title: I2C interface using AVR Two-Wire Interface (TWI) hardware
// Author: Pascal Stang - Copyright (C) 2002-2003
// Created: 2002.06.25
// Revised: 2003.03.02
// Version: 0.9
// Target MCU: Atmel AVR series
// Editor Tabs: 4
//
// This code is distributed under the GNU Public License
//which can be found at http://www.gnu.org/licenses/gpl.txt
//
//*****************************************************************************
#include <avr/io.h>
#include <avr/interrupt.h>
#include "i2c_prycon.h"
#include "global.h"
// include project-specific configuration
#include "i2cconf.h"
#ifdef I2C_DEBUG
#include "rprintf.h"// include printf function library
#include "uart2.h"
#endif
// Standard I2C bit rates are:
// 100KHz for slow speed
// 400KHz for high speed
//#define I2C_DEBUG
// I2C state and address variables
static volatile eI2cStateType I2cState;
static u08 I2cDeviceAddrRW;
// send/transmit buffer (outgoing data)
static u08 I2cSendData[I2C_SEND_DATA_BUFFER_SIZE];
static u08 I2cSendDataIndex;
static u08 I2cSendDataLength;
// receive buffer (incoming data)
static u08 I2cReceiveData[I2C_RECEIVE_DATA_BUFFER_SIZE];
static u08 I2cReceiveDataIndex;
static u08 I2cReceiveDataLength;
// function pointer to i2c receive routine
//! I2cSlaveReceive is called when this processor
// is addressed as a slave for writing
static void (*i2cSlaveReceive)(u08 receiveDataLength, u08* recieveData);
//! I2cSlaveTransmit is called when this processor
// is addressed as a slave for reading
static u08 (*i2cSlaveTransmit)(u08 transmitDataLengthMax, u08* transmitData);
// functions
void i2cInit(void)
{
// set pull-up resistors on I2C bus pins
// TODO: should #ifdef these
sbi(PORTC, 0);// i2c SCL on ATmega163,323,16,32,etc
sbi(PORTC, 1);// i2c SDA on ATmega163,323,16,32,etc
//sbi(PORTD, 0);// i2c SCL on ATmega128,64
//sbi(PORTD, 1);// i2c SDA on ATmega128,64
// clear SlaveReceive and SlaveTransmit handler to null
i2cSlaveReceive = 0;
i2cSlaveTransmit = 0;
// set i2c bit rate to 100KHz
i2cSetBitrate(100);
// enable TWI (two-wire interface)
sbi(TWCR, TWEN);
// set state
I2cState = I2C_IDLE;
// enable TWI interrupt and slave address ACK
sbi(TWCR, TWIE);
sbi(TWCR, TWEA);
//outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
// enable interrupts
sei();
}
void i2cSetBitrate(u16 bitrateKHz)
{
u08 bitrate_div;
// set i2c bitrate
// SCL freq = F_CPU/(16+2*TWBR))
#ifdef TWPS0
// for processors with additional bitrate division (mega128)
// SCL freq = F_CPU/(16+2*TWBR*4^TWPS)
// set TWPS to zero
cbi(TWSR, TWPS0);
cbi(TWSR, TWPS1);
#endif
// calculate bitrate division
bitrate_div = ((F_CPU/1000l)/bitrateKHz);
if(bitrate_div >= 16)
bitrate_div = (bitrate_div-16)/2;
outb(TWBR, bitrate_div);
}
void i2cSetLocalDeviceAddr(u08 deviceAddr, u08 genCallEn)
{
// set local device address (used in slave mode only)
outb(TWAR, ((deviceAddr&0xFE) | (genCallEn?1:0)) );
}
void i2cSetSlaveReceiveHandler(void (*i2cSlaveRx_func)(u08 receiveDataLength, u08* recieveData))
{
i2cSlaveReceive = i2cSlaveRx_func;
}
void i2cSetSlaveTransmitHandler(u08 (*i2cSlaveTx_func)(u08 transmitDataLengthMax, u08* transmitData))
{
i2cSlaveTransmit = i2cSlaveTx_func;
}
inline void i2cSendStart(void)
{
// send start condition
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWSTA));
}
inline void i2cSendStop(void)
{
// transmit stop condition
// leave with TWEA on for slave receiving
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA)|BV(TWSTO));
}
inline void i2cWaitForComplete(void)
{
// wait for i2c interface to complete operation
while( !(inb(TWCR) & BV(TWINT)) );
}
inline void i2cSendByte(u08 data)
{
// save data to the TWDR
outb(TWDR, data);
// begin send
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT));
}
inline void i2cReceiveByte(u08 ackFlag)
{
// begin receive over i2c
if( ackFlag )
{
// ackFlag = TRUE: ACK the recevied data
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
}
else
{
// ackFlag = FALSE: NACK the recevied data
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT));
}
}
inline u08 i2cGetReceivedByte(void)
{
// retieve received data byte from i2c TWDR
return( inb(TWDR) );
}
inline u08 i2cGetStatus(void)
{
// retieve current i2c status from i2c TWSR
return( inb(TWSR) );
}
void i2cMasterSend(u08 deviceAddr, u08 length, u08* data)
{
u08 i;
// wait for interface to be ready
while(I2cState);
// set state
I2cState = I2C_MASTER_TX;
// save data
I2cDeviceAddrRW = (deviceAddr & 0xFE);// RW cleared: write operation
for(i=0; i<length; i++)
I2cSendData[i] = *data++;
I2cSendDataIndex = 0;
I2cSendDataLength = length;
// send start condition
i2cSendStart();
}
void i2cMasterReceive(u08 deviceAddr, u08 length)
{
// wait for interface to be ready
while(I2cState);
// set state
I2cState = I2C_MASTER_RX;
// save data
I2cDeviceAddrRW = (deviceAddr|0x01);// RW set: read operation
I2cReceiveDataIndex = 0;
I2cReceiveDataLength = length;
// send start condition
i2cSendStart();
}
void i2cMasterReceiveBuffer(u08 length, u08* data)
{
u08 i;
// wait for data
while(I2cState);
// return data
for(i=0; i<length; i++)
*data++ = I2cReceiveData[i];
}
u08 i2cMasterSendNI(u08 deviceAddr, u08 length, u08* data)
{
u08 retval = I2C_OK;
// disable TWI interrupt
cbi(TWCR, TWIE);
// send start condition
i2cSendStart();
i2cWaitForComplete();
// send device address with write
i2cSendByte( deviceAddr & 0xFE );
i2cWaitForComplete();
// check if device is present and live
if( inb(TWSR) == TW_MT_SLA_ACK)
{
// send data
while(length)
{
i2cSendByte( *data++ );
i2cWaitForComplete();
length--;
}
}
else
{
// device did not ACK it's address,
// data will not be transferred
// return error
retval = I2C_ERROR_NODEV;
}
// transmit stop condition
// leave with TWEA on for slave receiving
i2cSendStop();
while( !(inb(TWCR) & BV(TWSTO)) );
// enable TWI interrupt
sbi(TWCR, TWIE);
return retval;
}
u08 i2cMasterReceiveNI(u08 deviceAddr, u08 length, u08 *data)
{
u08 retval = I2C_OK;
// disable TWI interrupt
cbi(TWCR, TWIE);
// send start condition
i2cSendStart();
i2cWaitForComplete();
// send device address with read
i2cSendByte( deviceAddr | 0x01 );
i2cWaitForComplete();
// check if device is present and live
if( inb(TWSR) == TW_MR_SLA_ACK)
{
// accept receive data and ack it
while(length > 1)
{
i2cReceiveByte(TRUE);
i2cWaitForComplete();
*data++ = i2cGetReceivedByte();
// decrement length
length--;
}
// accept receive data and nack it (last-byte signal)
i2cReceiveByte(FALSE);
i2cWaitForComplete();
*data++ = i2cGetReceivedByte();
}
else
{
// device did not ACK it's address,
// data will not be transferred
// return error
retval = I2C_ERROR_NODEV;
}
// transmit stop condition
// leave with TWEA on for slave receiving
i2cSendStop();
// enable TWI interrupt
sbi(TWCR, TWIE);
return retval;
}
/*
void i2cMasterTransferNI(u08 deviceAddr, u08 sendlength, u08* senddata, u08 receivelength, u08* receivedata)
{
// disable TWI interrupt
cbi(TWCR, TWIE);
// send start condition
i2cSendStart();
i2cWaitForComplete();
// if there's data to be sent, do it
if(sendlength)
{
// send device address with write
i2cSendByte( deviceAddr & 0xFE );
i2cWaitForComplete();
// send data
while(sendlength)
{
i2cSendByte( *senddata++ );
i2cWaitForComplete();
sendlength--;
}
}
// if there's data to be received, do it
if(receivelength)
{
// send repeated start condition
i2cSendStart();
i2cWaitForComplete();
// send device address with read
i2cSendByte( deviceAddr | 0x01 );
i2cWaitForComplete();
// accept receive data and ack it
while(receivelength > 1)
{
i2cReceiveByte(TRUE);
i2cWaitForComplete();
*receivedata++ = i2cGetReceivedByte();
// decrement length
receivelength--;
}
// accept receive data and nack it (last-byte signal)
i2cReceiveByte(TRUE);
i2cWaitForComplete();
*receivedata++ = i2cGetReceivedByte();
}
// transmit stop condition
// leave with TWEA on for slave receiving
i2cSendStop();
while( !(inb(TWCR) & BV(TWSTO)) );
// enable TWI interrupt
sbi(TWCR, TWIE);
}
*/
//! I2C (TWI) interrupt service routine
ISR(TWI_vect)
{
// read status bits
u08 status = inb(TWSR) & TWSR_STATUS_MASK;
switch(status)
{
// Master General
case TW_START:// 0x08: Sent start condition
case TW_REP_START:// 0x10: Sent repeated start condition
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: M->START\r\n");
rprintfInit(uart1SendByte);
#endif
// send device address
i2cSendByte(I2cDeviceAddrRW);
break;
// Master Transmitter & Receiver status codes
case TW_MT_SLA_ACK:// 0x18: Slave address acknowledged
case TW_MT_DATA_ACK:// 0x28: Data acknowledged
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: MT->SLA_ACK or DATA_ACK\r\n");
rprintfInit(uart1SendByte);
#endif
if(I2cSendDataIndex < I2cSendDataLength)
{
// send data
i2cSendByte( I2cSendData[I2cSendDataIndex++] );
}
else
{
// transmit stop condition, enable SLA ACK
i2cSendStop();
// set state
I2cState = I2C_IDLE;
}
break;
case TW_MR_DATA_NACK:// 0x58: Data received, NACK reply issued
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: MR->DATA_NACK\r\n");
rprintfInit(uart1SendByte);
#endif
// store final received data byte
I2cReceiveData[I2cReceiveDataIndex++] = inb(TWDR);
// continue to transmit STOP condition
case TW_MR_SLA_NACK:// 0x48: Slave address not acknowledged
case TW_MT_SLA_NACK:// 0x20: Slave address not acknowledged
case TW_MT_DATA_NACK:// 0x30: Data not acknowledged
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: MTR->SLA_NACK or MT->DATA_NACK\r\n");
rprintfInit(uart1SendByte);
#endif
// transmit stop condition, enable SLA ACK
i2cSendStop();
// set state
I2cState = I2C_IDLE;
break;
case TW_MT_ARB_LOST:// 0x38: Bus arbitration lost
//case TW_MR_ARB_LOST:// 0x38: Bus arbitration lost
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: MT->ARB_LOST\r\n");
rprintfInit(uart1SendByte);
#endif
// release bus
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT));
// set state
I2cState = I2C_IDLE;
// release bus and transmit start when bus is free
//outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWSTA));
break;
case TW_MR_DATA_ACK:// 0x50: Data acknowledged
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: MR->DATA_ACK\r\n");
rprintfInit(uart1SendByte);
#endif
// store received data byte
I2cReceiveData[I2cReceiveDataIndex++] = inb(TWDR);
// fall-through to see if more bytes will be received
case TW_MR_SLA_ACK:// 0x40: Slave address acknowledged
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: MR->SLA_ACK\r\n");
rprintfInit(uart1SendByte);
#endif
if(I2cReceiveDataIndex < (I2cReceiveDataLength-1))
// data byte will be received, reply with ACK (more bytes in transfer)
i2cReceiveByte(TRUE);
else
// data byte will be received, reply with NACK (final byte in transfer)
i2cReceiveByte(FALSE);
break;
// Slave Receiver status codes
case TW_SR_SLA_ACK:// 0x60: own SLA+W has been received, ACK has been returned
case TW_SR_ARB_LOST_SLA_ACK:// 0x68: own SLA+W has been received, ACK has been returned
case TW_SR_GCALL_ACK:// 0x70: GCA+W has been received, ACK has been returned
case TW_SR_ARB_LOST_GCALL_ACK:// 0x78: GCA+W has been received, ACK has been returned
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: SR->SLA_ACK\r\n");
rprintfInit(uart1SendByte);
#endif
// we are being addressed as slave for writing (data will be received from master)
// set state
I2cState = I2C_SLAVE_RX;
// prepare buffer
I2cReceiveDataIndex = 0;
// receive data byte and return ACK
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
break;
case TW_SR_DATA_ACK:// 0x80: data byte has been received, ACK has been returned
case TW_SR_GCALL_DATA_ACK:// 0x90: data byte has been received, ACK has been returned
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: SR->DATA_ACK\r\n");
rprintfInit(uart1SendByte);
#endif
// get previously received data byte
I2cReceiveData[I2cReceiveDataIndex++] = inb(TWDR);
// check receive buffer status
if(I2cReceiveDataIndex < I2C_RECEIVE_DATA_BUFFER_SIZE)
{
// receive data byte and return ACK
i2cReceiveByte(TRUE);
//outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
}
else
{
// receive data byte and return NACK
i2cReceiveByte(FALSE);
//outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT));
}
break;
case TW_SR_DATA_NACK:// 0x88: data byte has been received, NACK has been returned
case TW_SR_GCALL_DATA_NACK:// 0x98: data byte has been received, NACK has been returned
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: SR->DATA_NACK\r\n");
rprintfInit(uart1SendByte);
#endif
// receive data byte and return NACK
i2cReceiveByte(FALSE);
//outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT));
break;
case TW_SR_STOP:// 0xA0: STOP or REPEATED START has been received while addressed as slave
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: SR->SR_STOP\r\n");
rprintfInit(uart1SendByte);
#endif
// switch to SR mode with SLA ACK
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
// i2c receive is complete, call i2cSlaveReceive
if(i2cSlaveReceive) i2cSlaveReceive(I2cReceiveDataIndex, I2cReceiveData);
// set state
I2cState = I2C_IDLE;
break;
// Slave Transmitter
case TW_ST_SLA_ACK:// 0xA8: own SLA+R has been received, ACK has been returned
case TW_ST_ARB_LOST_SLA_ACK:// 0xB0: GCA+R has been received, ACK has been returned
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: ST->SLA_ACK\r\n");
rprintfInit(uart1SendByte);
#endif
// we are being addressed as slave for reading (data must be transmitted back to master)
// set state
I2cState = I2C_SLAVE_TX;
// request data from application
if(i2cSlaveTransmit) I2cSendDataLength = i2cSlaveTransmit(I2C_SEND_DATA_BUFFER_SIZE, I2cSendData);
// reset data index
I2cSendDataIndex = 0;
// fall-through to transmit first data byte
case TW_ST_DATA_ACK:// 0xB8: data byte has been transmitted, ACK has been received
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: ST->DATA_ACK\r\n");
rprintfInit(uart1SendByte);
#endif
// transmit data byte
outb(TWDR, I2cSendData[I2cSendDataIndex++]);
if(I2cSendDataIndex < I2cSendDataLength)
// expect ACK to data byte
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
else
// expect NACK to data byte
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT));
break;
case TW_ST_DATA_NACK:// 0xC0: data byte has been transmitted, NACK has been received
case TW_ST_LAST_DATA:// 0xC8:
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: ST->DATA_NACK or LAST_DATA\r\n");
rprintfInit(uart1SendByte);
#endif
// all done
// switch to open slave
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
// set state
I2cState = I2C_IDLE;
break;
// Misc
case TW_NO_INFO:// 0xF8: No relevant state information
// do nothing
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: NO_INFO\r\n");
rprintfInit(uart1SendByte);
#endif
break;
case TW_BUS_ERROR:// 0x00: Bus error due to illegal start or stop condition
#ifdef I2C_DEBUG
rprintfInit(uart1AddToTxBuffer);
rprintf("I2C: BUS_ERROR\r\n");
rprintfInit(uart1SendByte);
#endif
// reset internal hardware and release bus
outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWSTO)|BV(TWEA));
// set state
I2cState = I2C_IDLE;
break;
}
}
eI2cStateType i2cGetState(void)
{
return I2cState;
}[/syntax]
Z biblioteki do projektu należy także dodać pliki prycona
avrlibdefs.h
avrlibtypes.h
global.h
i2cconf.h
a także MKUART z bluebooka.
(oryginalna obsługa i2c prycona nazywa się i2c.c oraz i2c.h w jego bibliotece)
Tutaj otrzymany wynik
Aby obsłużyć urządzenie należy napisać sobie funkcję podobną do MPU6050_Test_I2C(), która podzieli zadania na zapis (tutaj wysłanie do urządzenia adresu komórki do odczytu), odczyt z urządzenia (odczyt n bitów do bufora) i odczyt z bufora I2C do własnego bufora i wyświetlenie go. Jeżeli i2c jest aktualnie zajęte i2cGetState() to wracamy do pętli głównej i wykonujemy inne zadania.
Przez odpowiednią zmianę twiState sekwencyjnie dokonujemy zapisu, odczytu i odczytu z bufora. Następnie ustawiam twiState na TWI_IDLE aby ponownie zmienić stan na TWI_REQUEST_REGISTER i zwrócić funkcją wartość 1, która spowoduje 3 sekundowe opóźnienie w pętli głównej przed kolejnym odczytem.
Jak obsłużę całkowicie żyroskop to zabiorę się za przerobienie biblioteki na atnelowską modę.
Statystyki: Napisane przez Rzeczek — 7 sie 2015, o 12:46
]]>