Compiler Explorer

Source code

// #pragma once
//======================================================================
//  MyAvr.h
//======================================================================
#include <avr/io.h>
#include <stdint.h>
#include <stdbool.h>
#include <avr/interrupt.h>

//======================================================================
//  global F_CPU for delays, or any timing calculations
//======================================================================
#define F_CPU 3333333ul

#include <util/delay.h>

typedef uint8_t  u8;
typedef uint16_t u16;

// #pragma once
/*------------------------------------------------------------------------------
    twiPins.h - Twi pins

twi0 master/slave - (not dual mode)

mega0/DA    tiny0/1     tiny0/1 XX2 (8pin)
default SCL      PA3          PB0         PA2
default SDA      PA2          PB1         PA1
    alt SCL      PC3          PA2         --
    alt SDA      PC2          PA1         --
------------------------------------------------------------------------------*/
// #include "MyAvr.h"

//mega0
#if defined(PORTMUX_TWISPIROUTEA)
    #define TWI_PULL_DEFAULT()      PORTA.PIN3CTRL |= 1<<3; PORTA.PIN2CTRL |= 1<<3
    #define TWI_PULL_ALT()          PORTC.PIN3CTRL |= 1<<3; PORTC.PIN2CTRL |= 1<<3
    #define TWI_PORTMUX_DEFAULT()   PORTMUX.TWISPIROUTEA &= ~PORTMUX_TWI0_gm;
    #define TWI_PORTMUX_ALT()       PORTMUX.TWISPIROUTEA = (PORTMUX.TWISPIROUTEA & ~PORTMUX_TWI0_gm) | PORTMUX_TWI0_ALT2_gc;
//avrda
#elif defined(PORTMUX_TWIROUTEA)
    #define TWI_PULL_DEFAULT()      PORTA.PIN3CTRL |= 1<<3; PORTA.PIN2CTRL |= 1<<3
    #define TWI_PULL_ALT()          PORTC.PIN3CTRL |= 1<<3; PORTC.PIN2CTRL |= 1<<3
    #define TWI_PORTMUX_DEFAULT()   PORTMUX.TWIROUTEA &= ~PORTMUX_TWI0_gm;
    #define TWI_PORTMUX_ALT()       PORTMUX.TWIROUTEA = (PORTMUX.TWIROUTEA & ~PORTMUX_TWI0_gm) | PORTMUX_TWI0_ALT2_gc;
//tiny0/1 w/alternate pins
#elif defined(PORTMUX_CTRLB) && defined(PORTMUX_TWI0_bm)
    #define TWI_PULL_DEFAULT()      PORTB.PIN0CTRL |= 1<<3; PORTB.PIN1CTRL |= 1<<3
    #define TWI_PULL_ALT()          PORTA.PIN2CTRL |= 1<<3; PORTA.PIN1CTRL |= 1<<3
    #define TWI_PORTMUX_DEFAULT()   PORTMUX.CTRLB &= ~PORTMUX_TWI0_bm;
    #define TWI_PORTMUX_ALT()       PORTMUX.CTRLB |= PORTMUX_TWI0_bm;
//tiny0/1 no alternate pins
#elif defined(PORTMUX_CTRLB) && !defined(PORTMUX_TWI0_bm)
    #define TWI_PORTMUX_DEFAULT()
    #define TWI_PORTMUX_ALT()
    #define TWI_PULL_DEFAULT()      PORTA.PIN2CTRL |= 1<<3; PORTA.PIN1CTRL |= 1<<3
    #define TWI_PULL_ALT()          TWIS_PULL_DEFAULT()
//unknown
#else
    #error "Unknown portmux/pin settings for TWI0"
#endif

// #pragma once
/*------------------------------------------------------------------------------
    twim.h - Twi0, master - avr mega0, tiny0/1, da

1. select pins to use- default or alternate
        twim_defaultPins(); //pullups on, portmux set
    2. set baud
        twim_baud( F_CPU, 100000ul ); //100kHz
    3. turn on, specifying slave address
        twim_on(0x44);
    4. enable interrupts via sei() (avr/interrupts.h)

optionally set a callback function if not polling via twim_isBusy() or
    twim_waitUS()
        twim_callback(myCallback);

you can now use one of four functions to move data-

twim_writeRead - write wbuffer of wN length, read into rbuffer of rN length
    twim_writeWrite - write wbuffer of wN length, write wbuffer2 of w2N length
    twim_write - write wbuffer of wN length (alias to writeRead with no read)
    twim_read - read into rbuffer of rN length (alias to writeRead with no write)

if not using a callback function, you can poll for completion-

u8 wbuf[1] = { 0x55 }; //command to read 4 bytes, as an example
        u8 rbuf[4]; //no need to clear/init
        twim_writeRead( wbuf, 1, rbuf, 4 );

//blocking until done
        while( twim_isBusy() ){} //blocks until done
        if( twim_lastResultOK() ) //rbuf has 4 bytes
        else //was nack'd or bus error/collision

//or use a timeout in us
        if( twim_waitUS(3000) ) //rbuf has 4 bytes
        else if( twim_isBusy() ) //was timeout, (twim irqs may still be on)
        else //was nack'd or bus error/collision (twim irqs are off)

twim_off();

------------------------------------------------------------------------------*/
// #include "MyAvr.h"

typedef void (*twim_callbackT)(void);

void twim_off           ();
void twim_on            (u8 address);
bool twim_isBusy        ();
bool twim_lastResultOK  ();
void twim_callback      (twim_callbackT callbackFunction);
void twim_writeRead     (const u8* writeBuffer, u16 writeLength, u8* readBuffer, u16 readLength);
void twim_writeWrite    (const u8* writeBuffer, u16 writeLength, const u8* writeBuffer2, u16 writeLength2);
void twim_write         (const u8* writeBuffer, u16 writeLength);
void twim_read          (u8* readBuffer, u16 readLength);
bool twim_waitUS        (u16 microseconds);
void twim_defaultPins   ();
void twim_altPins       ();

__attribute((always_inline)) inline static
void twim_baud          (uint32_t cpuHz, uint32_t twiHz)
                        {
                        int32_t v = cpuHz/twiHz/2 - 5;
                        TWI0.MBAUD = v >= 0 ? v : 0;
                        }

//======================================================================
//  twim.c - Twi0, master - avr mega0, tiny0/1, da
//======================================================================
// #include "MyAvr.h"

// #include "twim.h"
// #include "twiPins.h"

//==========
    // private:
    //==========

typedef uint8_t  u8;
typedef uint16_t u16;

static twim_callbackT   isrFuncCallback_;
static const u8*        txbuf_;
static const u8*        txbufEnd_;
static const u8*        txbuf2_;
static const u8*        txbuf2End_;
static u8*              rxbuf_;
static const u8*        rxbufEnd_;
static volatile bool    lastResult_; //1=ok,0=fail

//local enums
//MCTRLB flush3|ack2|cmd1:0
enum { ACK = 0, READ = 2, STOP = 3, NACK = 4,  FLUSH = 8 };
//MSTATUS RIF7|WIF6|CLKHOLD5|RXACK4|ARBLOST3|BUSERR2|BUSSTATE1:0
enum { RIF = 0x80, WIF = 0x40, CLKHOLD = 0x20, RXNACK = 0x10, ARBLOST = 0x8, BUSERR = 0x4 };
enum { ALLFLAGS = RIF|WIF|CLKHOLD|ARBLOST|BUSERR };
enum { ANYERR = ARBLOST|BUSERR }; //error bits
enum { RIEN = RIF, WIEN = WIF, RWIEN = RIEN|WIEN }; //irq bits
enum { RW = 1 }; //address bit0
enum { UNKNOWN = 0, IDLE, OWNER, BUSBUSY, BUSMASK = 3 }; //bus state
enum { READOK = RIF|CLKHOLD|OWNER, WRITEOK = WIF|CLKHOLD|OWNER };
enum { ENABLE = 1 }; //on/off

static void on              () { TWI0.MCTRLA |= ENABLE; }
static void off             () { TWI0.MCTRLA = 0; }
static void irqAllOn        () { TWI0.MCTRLA |=  RWIEN; }
static void irqAllOff       () { TWI0.MCTRLA &= ~RWIEN; }
static void toStateIdle     () { TWI0.MSTATUS = ALLFLAGS|IDLE; } //clear flags, set to IDLE
static void ackActionACK    () { TWI0.MCTRLB = ACK; }
static void ACKread         () { TWI0.MCTRLB = READ; }
static void NACKstop        () { TWI0.MCTRLB = NACK|STOP; }
static void address         (u8 v) { off(); TWI0.MADDR = v<<1; } //off so no start produced
static void startRead       () { ackActionACK(); TWI0.MADDR |= RW; } //reuse existing address
static void startWrite      () { TWI0.MADDR &= ~RW; }   //reuse existing address
static void write           (u8 v) { TWI0.MDATA = v; }
static u8   read            () { return TWI0.MDATA; }
static u8   status          () { return TWI0.MSTATUS; }
static bool isBusy          () { return TWI0.MCTRLA & RWIEN; }

//start a read or write, enable irq
static void startIrq        (bool wr)
                            {
                            if( wr ) startWrite(); else startRead();
                            lastResult_ = false;
                            irqAllOn();
                            }

//for isr use
static void finished        (bool tf)
                            {
                            lastResult_ = tf;
                            //NACKstop works for write also (nack not done, harmless)
                            NACKstop();
                            irqAllOff(); //do before callback in case call back starts another xfer
                            if( isrFuncCallback_ ) isrFuncCallback_();
                            }

ISR(TWI0_TWIM_vect)         {
                            u8 s = status();
                            //error
                            if( s & ANYERR ) return finished( false );
                            //read
                            if( s == READOK ){
                                *rxbuf_++ = read();
                                return rxbuf_ < rxbufEnd_ ? ACKread() : finished( true );
                                }
                            //write
                            if( s == WRITEOK ){
                                if( txbuf_ < txbufEnd_ ) return write( *txbuf_++ ); //more data
                                if( txbuf2_ < txbuf2End_ ) return write( *txbuf2_++ ); //more data
                                return rxbuf_ ? startRead() : finished( true ); //switch to read? or done
                                }
                            //unknown, or a write nack
                            finished( false );
                            }

//==========
    // public:
    //==========

void    twim_callback       (twim_callbackT cb) { isrFuncCallback_ = cb; } //optional, else use twim_waitUS
void    twim_off            () { off(); }
void    twim_on             (u8 addr) { address(addr); toStateIdle(); on(); }
bool    twim_isBusy         () { return isBusy(); } //if irq on, is busy
bool    twim_lastResultOK   () { return lastResult_; }

//set default or alternate pins
void    twim_defaultPins    () { TWI_PULL_DEFAULT(); TWI_PORTMUX_DEFAULT(); }
void    twim_altPins        () { TWI_PULL_ALT(); TWI_PORTMUX_ALT(); }

//write+read (or write only, or read only)
void    twim_writeRead      (const u8* wbuf, u16 wn, u8* rbuf, u16 rn)
                            {
                            txbuf_ = wbuf; txbufEnd_ = &wbuf[wn];
                            rxbuf_ = rbuf; rxbufEnd_ = &rbuf[rn];
                            txbuf2_ = 0; txbuf2End_ = 0;
                            startIrq( wn ); //if no write (wn==0), then will start a read irq
                            }

//write/write (such as a command, then a buffer)
void    twim_writeWrite     (const u8* wbuf, u16 wn, const u8* wbuf2, u16 wn2)
                            {
                            txbuf_ = wbuf; txbufEnd_ = &wbuf[wn];
                            txbuf2_ = wbuf2; txbuf2End_ = &wbuf2[wn2];
                            rxbuf_ = 0; rxbufEnd_ = 0; //no read
                            startIrq( 1 ); //write only
                            }

//write only alias
void    twim_write          (const u8* wbuf, u16 wn) { twim_writeRead( wbuf, wn, 0, 0); }

//read only alias
void    twim_read           (u8* rbuf, u16 rn) { twim_writeRead( 0, 0, rbuf, rn); }

//blocking wait with timeout
bool    twim_waitUS         (u16 us)
                            {
                            while( _delay_us(1), --us && twim_isBusy() ){}
                            return twim_lastResultOK();
                            //lastResult_ is set to false at start of transaction
                            //will still be false if timeout
                            //check twim_isBusy() on your own to see if was a timeout (if returned false)
                            }

//atmel start i2c example using above code
#define slave_adr 0x4f
#define slave_reg_adr 0x0

uint8_t read_data[2];

bool I2C_0_test_i2c_master(void)
{
    twim_defaultPins(); //pullups on, portmux set
    twim_baud( F_CPU, 100000ul ); //100kHz
    twim_on( slave_adr );
    u8 wbuf[1] = { slave_reg_adr };
	twim_writeRead(wbuf, sizeof wbuf, read_data, sizeof read_data);
    bool ret = twim_waitUS( 3000 ); //wait up to 3ms for transaction
    twim_off(); //in any case (timeout, error, ok), turn off twim
    return ret; //true=ok, false=timeout or some other failure
}

int main(){

sei();
    while(1){
        I2C_0_test_i2c_master();
        }

}