Compiler Explorer

Source code

// #pragma once
//======================================================================
//  MyAvr.h - global includes/defines, etc.
//======================================================================
#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 int8_t   i8;
typedef uint16_t u16;
typedef int16_t  i16;
typedef uint32_t u32;
typedef int32_t  i32;

// #pragma once
//======================================================================
//  twiPins.h
//======================================================================
// #include "MyAvr.h"

/*------------------------------------------------------------------------------
    twi0 master/slave - basic/limited table for twim0 (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         --

add new mcu's to this pin info table as needed

uncomment the set of pins that suits your mcu (instead of using a 
    series of ifdef's which get harder to manage as more mcu's are added)

add more as needed (can also add twi1_ pins if needed)

portmux register names are not all the same, and the twi 
    bitfields in the portmux register also can be different
    so will have to look these names up when creating a new
    pair of pins

master/slave pins are the same for many mcu's, but is split so one can
    use dual mode for those mcu's which are able to use a different set of 
    pins for master/slave
------------------------------------------------------------------------------*/
                typedef struct {
                    PORT_t* Mport;              // master port- &PORTn
                    uint8_t MpinSCL;            // 0-7
                    uint8_t MpinSCA;            // 0-7
                    PORT_t* Sport;              // slave port- &PORTn
                    uint8_t SpinSCL;            // 0-7
                    uint8_t SpinSCA;            // 0-7
                    volatile uint8_t* pmux;     // &PORTMUX.twi_register
                    uint8_t pmux_clrbm;         // bitmask values to clear/set the appropriate twi bitfields in portmux to select a set of pins
                    uint8_t pmux_setbm;         //  the clrbm (inverted) will be used to reset bitfield to default, the setbm will set the desired value
                } 
const 
twiPins_t;

//------------------------------
// mega0
//------------------------------
                static twiPins_t //std
twi0_pins       = { &PORTA, 3, 2, &PORTA, 3, 2, &PORTMUX_TWISPIROUTEA, PORTMUX_TWI0_gm, 0 };
//                 static twiPins_t //alt
// twi0_pins       = { &PORTC, 3, 2,  &PORTC, 3, 2, &PORTMUX_TWISPIROUTEA, PORTMUX_TWI0_gm, PORTMUX_TWI0_ALT2_gc };

//------------------------------
// avrda
//------------------------------
//                 static twiPins_t //std
// twi0_pins       = { &PORTA, 3, 2, &PORTA, 3, 2, &PORTMUX_TWIROUTEA, PORTMUX_TWI0_gm, 0 };
//                 static twiPins_t //alt
// twi0_pins       = { &PORTC, 3, 2, &PORTC, 3, 2, &PORTMUX_TWIROUTEA, PORTMUX_TWI0_gm, PORTMUX_TWI0_ALT2_gc };

//------------------------------
// tiny0/1 w/alternate pins
//------------------------------
//                 static twiPins_t //std
// twi0_pins       = { &PORTB, 0, 1, &PORTB, 0, 1, &PORTMUX_CTRLB, PORTMUX_TWI0_bm, 0 };
//                 static twiPins_t //alt
// twi0_pins       = { &PORTA, 2, 1, &PORTA, 2, 1, &PORTMUX_CTRLB, PORTMUX_TWI0_bm, PORTMUX_TWI0_bm };

//------------------------------
// tiny0/1 no alternate pins
//------------------------------
//                 static twiPins_t //std only
// twi0_std_pins   = { &PORTB, 0, 1, &PORTB, 0, 1, 0, 0, 0 }; //pmux = 0 (no twi portmux)

// #pragma once
//======================================================================
//  twim0.h - Twi0, master - avr mega0, tiny0/1, da, etc.
//======================================================================
// #include "MyAvr.h"

/*------------------------------------------------------------------------------
    1. uncomment the appropriate set of pins for your mcu
        in twiPins.h to select the twi pins to use
    2. set baud
        twim0_baud( F_CPU, 100000ul ); //100kHz
    3. turn on, specifying slave address
        twim0_on( 0x44 );
    4. enable interrupts via sei() (avr/interrupts.h)

optionally set a callback function if not polling via twim0_waitUS()
        twim0_callback( myCallback );

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

twim0_writeRead - write wbuffer of wN length, read into rbuffer of rN length
    twim0_writeWrite - write wbuffer of wN length, write wbuffer2 of w2N length
    twim0_write - write wbuffer of wN length (alias to writeRead with no read)
    twim0_read - read into rbuffer of rN length (alias to writeRead with no write)

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

twim0_baud( F_CPU, 100000ul );
        twim0_on( 0x44 );
        sei();

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

//blocking until done or a timeout (us)
        if( twim0_waitUS(3000) ){}          //result ok, rbuf has 4 bytes
        else if( twim0_isBusy() ){          //was timeout, (twim irqs may still be on)
            twim0_busRecovery();            //can do bus recovery if wanted
            }
        else {}                             //was nack'd or bus error/collision (twim irqs are off)

twim0_off();

NOTE: FM+ mode is always used but if do not want it you can modify
              the twim0_on() function
------------------------------------------------------------------------------*/

typedef void (*twim_callbackT)(void);

void twim0_on           (u8 address);
void twim0_off          ();
bool twim0_isBusy       ();
bool twim0_resultOK     ();
void twim0_callback     (twim_callbackT callbackFunction);
void twim0_writeRead    (const u8* writeBuffer, u16 writeLength, u8* readBuffer, u16 readLength);
void twim0_writeWrite   (const u8* writeBuffer, u16 writeLength, const u8* writeBuffer2, u16 writeLength2);
void twim0_write        (const u8* writeBuffer, u16 writeLength);
void twim0_read         (u8* readBuffer, u16 readLength);
bool twim0_waitUS       (u16 microseconds);
void twim0_busRecovery  ();

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

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

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

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.CTRLA |= 2; TWI0.MCTRLA |= ENABLE; } //FM+ enable in ctrla
                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; }

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

static void
finished        (bool tf) //for isr use, tf=true if success
                {
                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 );
                }

static void 
initPins        (bool busRecovery) //false = no bus recovery, true = also do bus recovery
                { 
                uint8_t
                    scl = twi0_pins.MpinSCL & 7,        //extract all values for easier use/reading
                    sca = twi0_pins.MpinSCA & 7, 
                    clrbm = ~twi0_pins.pmux_clrbm,      //inverted for bitand use
                    setbm = twi0_pins.pmux_setbm;
                volatile uint8_t *pinctrl = &twi0_pins.Mport->PIN0CTRL; 
                volatile uint8_t *pmux = twi0_pins.pmux;

off(); //turn off twi

//enable pullups and set portmux as needed (some have no alt pins, so no twi portmux)
                pinctrl[scl] = PORT_PULLUPEN_bm; //assignment, will set all other bits to 0
                pinctrl[sca] = PORT_PULLUPEN_bm; // if need invert or isc bits for some reason, change to |=
                if( pmux ) *pmux = (*pmux & clrbm) | setbm; //compiler will optimize if bitfield is a single bit
                if( busRecovery == false ) return;

//also do bus recovery

uint8_t sclbm = 1<<(twi0_pins.MpinSCL & 7), scabm = 1<<(twi0_pins.MpinSCA & 7);
                PORT_t* pt = twi0_pins.Mport;

pt->OUTSET = sclbm;             //scl high
                pt->DIRSET = sclbm;             //scl output
                for( u8 i = 0; i < 19; i++ ){   //10 clocks (20 toggles, but leave low so 19)
                    pt->OUTTGL = sclbm;
                    _delay_us( 5 );             //5us half cycle = 100khz
                    }
                //produce a stop 
                pt->OUTCLR = scabm;             //sca low
                pt->DIRSET = scabm;             //sca output
                _delay_us( 30 );
                pt->DIRCLR = sclbm;             //scl back to input w/pullup
                _delay_us( 30 );
                pt->DIRCLR = scabm;             //sca back to input w/pullup
                }

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

void
twim0_callback  (twim_callbackT cb) { isrFuncCallback_ = cb; } //optional, else use twim_waitUS
                void
twim0_off       () { off(); }
                void
twim0_on        (u8 addr) 
                { 
                initPins(false); //will also turn off twim (false=no bus recovery)
                address(addr); 
                toStateIdle(); 
                on(); 
                }
                bool
twim0_isBusy    () { return isBusy(); } //if irq on, is busy
                bool
twim0_resultOK  () { return lastResult_; }

//write+read (or write only, or read only)
                void
twim0_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
twim0_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
twim0_write     (const u8* wbuf, u16 wn) { twim0_writeRead( wbuf, wn, 0, 0); }

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

//blocking wait with timeout
                //if false is returned, caller can check twim0_isBusy() to see
                //if was a timeout or an error (isBusy will be true if timeout)
                //caller then can do a bus recovery if wanted
                bool
twim0_waitUS    (u16 us)
                {
                while( _delay_us(1), --us && twim0_isBusy() ){}
                return twim0_resultOK(); //true = ok, false = error or timeout
                }

//recover locked up bus
                //NOTE: if you are running the slave on the same pins for some reason
                //      (not normal), the slave will also need to be disabled so it
                //      releases its pins (which are the same pins)
                void 
twim0_busRecovery() { initPins(true); }

/*------------------------------------------------------------------------------
    wait - uses _delay_ms (so we can have a simple callable delay with
           variable runtime values)
------------------------------------------------------------------------------*/
                static void
waitMS          (u16 ms){ while( ms-- ) _delay_ms(1); }

/*------------------------------------------------------------------------------
    led - PA7
------------------------------------------------------------------------------*/
                typedef struct { PORT_t* port; u8 pin; bool invert; }
const
pin_t;
                static pin_t            //set as needed for your board
led             = { &PORTA, 7, false };  //PA7, high is on

static void
pinSet          (pin_t p, bool on)
                {
                u8 pinbm = 1<<(p.pin & 7);
                p.port->DIRSET = pinbm;
                if( p.invert ) (&p.port->PIN0CTRL)[p.pin] |= 0x80;
                on ? (p.port->OUTSET = pinbm) : (p.port->OUTCLR = pinbm);
                }

/*------------------------------------------------------------------------------
    read eeprom
------------------------------------------------------------------------------*/
                enum { AT24C256_DEV_ADDR = 0x50, AT24C256_ADDR_MASK = 0x7FFF  };

static u8
AT24C256_read   (u16 addr, u8* v)
                {
                addr &= AT24C256_ADDR_MASK;
                twim0_baud( F_CPU, 100000ul );
                twim0_on( AT24C256_DEV_ADDR );
                u8 wrbuf[2] = { addr>>8, addr }; //HH, LL
                twim0_writeRead( wrbuf, sizeof(wrbuf), v, 1 ); //write u16 address, read data
                bool ret = twim0_waitUS( 3000 );
                twim0_off();
                if( ret = false ) twim0_busRecovery();
                return ret;
                }

/*------------------------------------------------------------------------------
    main
------------------------------------------------------------------------------*/

int
main            ()
                {

sei();
                u16 addr = 0;
                u8 eedata = 0;

//4hz read, if reads ok led will flash at 4hz
                while(1){                    
                    bool ok = AT24C256_read( addr, &eedata );
                    if( ok ) pinSet( led, 1 );
                    waitMS( 50 );
                    pinSet( led, 0 );
                    waitMS( 200 );
                    addr++;
                    }

}