Compiler Explorer

Source code

/*----------------------------------------------------
    Twi.h header avr0/1
    Twi_function is global function
----------------------------------------------------*/
#include <stdint.h>
#include <stdbool.h>
#define U8 uint8_t

void Twi_baudReg    (U8 v);
void Twi_on         ();
bool Twi_readBytes  (U8* buf, const U8 len, bool doStop);
bool Twi_writeBytes (const U8* buf, const U8 len, bool doStop);

#undef U8
/*----------------------------------------------------
    end Twi.h
----------------------------------------------------*/

/*----------------------------------------------------
    Twi.c avr0/1
    Twi_function is global function, the rest are
    local and can be made static if wanted
----------------------------------------------------*/
#include <avr/io.h>
#include <stdint.h>
#include <stdbool.h>
//#include "Twi.h"
#define U8 uint8_t

bool isAnyFlag      ()      { return TWI0.MSTATUS & 0b11101100; } //rif,wif,hold,arblost,buserr
bool isAnyErrFlag   ()      { return TWI0.MSTATUS & 0b00001100; } //arblost,buserr
void clearErrFlags  ()      { TWI0.MSTATUS = 0b00001100; } //arblost,buserr
void addressRead    (U8 v)  { TWI0.MADDR = (v<<1) | 1; }
void addressWrite   (U8 v)  { TWI0.MADDR = v<<1; }
void dataWR         (U8 v)  { TWI0.MDATA = v; }
U8   dataRD         ()      { return TWI0.MDATA; }
void toStateIdle    ()      { TWI0.MSTATUS = 0b11101101; } //clear all flags, IDLE
void NACKstop       ()      { TWI0.MCTRLB = 0b0111; } //NACK,stop
void stop           ()      { TWI0.MCTRLB = 0b0011; } //ACK,stop
void ackActionACK   ()      { TWI0.MCTRLB = 0b0000; } //ACk,no cmd
void ACKread        ()      { TWI0.MCTRLB = 0b0010; } //ACK,read
bool isWriteOK      ()      { return TWI0.MSTATUS == 0b01100010; } //wif,hold,rxack=0,owner = ok
bool isReadOK       ()      { return TWI0.MSTATUS == 0b10100010; } //rif,hold,rxack=0(from a previous write ack),owner = ok

void Twi_baudReg    (U8 v)  { TWI0.MBAUD = v; }
void Twi_on         ()      { toStateIdle(); TWI0.MCTRLA = 1; }

/*
can make timeout whatever you want, is 256 in this case
which is 256x whatever clocks this code needs (loop code + isAnyFlags() )
and is probably plenty

an scl bit takes at most 200 clocks (when using 95 as baud value)
so 9 bits = 1800 clocks

256x maybe 25 clocks for this loop code, so maybe 6000+ clocks
as timeout, or about 30+ scl bit times
*/
bool waitTimeout () {
    U8 t = 0;
    while( ++t && !isAnyFlag() );
    return t != 0; //if t==0, is timeout, t!=0 is any flag set
}

//if any error flags, just clear error flags, else send stop
static void anyFail () {
    if( isAnyErrFlag() ) clearErrFlags(); //or toStateIdle() if want to force state
    else stop();
}

//wait for timeout or any flag, 
//return true if flags are what we want
static bool waitWriteOK () {
    if( waitTimeout() && isWriteOK() ) return true;
    anyFail();
    return false;
}

//wait for timeout or any flag, 
//return true if flags are what we want
static bool waitReadOK () {
    if( waitTimeout() && isReadOK() ) return true;
    anyFail();
    return false;
}

// buf[0] = address, len = bytes to read into buf, doStop = true = stop when done
// return true if bytes read == len
bool Twi_readBytes (U8* buf, const U8 len, bool doStop) {
    U8 readLen = 0;
    ackActionACK();                            //we ack reads
    addressRead(*buf);                         //start, ack, read 1 byte
    //if was ok, we already have 1 byte
    while( true ){
        if( ! waitReadOK() ) return false;     //error?
        *buf++ = dataRD();                     //store data
        if( ++readLen >= len ) break;          //done?
        ACKread();                             //allow read next byte
    }
    if( doStop ) NACKstop();                   //send stop? (also NACK last read)
    return true;
}

// buf[0] = address, len = bytes to write from buf, doStop = true = stop when done
// return true if bytes written == len
bool Twi_writeBytes (const U8* buf, const U8 len, bool doStop) {
    U8 writeLen = 0;
    addressWrite(*buf++);                        //start
    while( true ){
        if( ! waitWriteOK() ) return false;      //error? (or NACK)
        if( ++writeLen >= len ) break;           //more?
        dataWR(*buf++);                          //send next byte
    }
    if( doStop ) stop();                         //send stop?
    return true;
}

#undef U8
/*----------------------------------------------------
    end Twi.c
----------------------------------------------------*/

// #include "Twi.h"
// #include <stdint.h>
uint16_t id = 0;
int main(){

Twi_baudReg( 95 );                         //100kHz@20MHz, 50kHz@10Mhz, etc.
    Twi_on();                                  //to IDLE, enable

const uint8_t addr = 0x48;                 //TMP117 address
    uint8_t buf[2] = { addr, 15 };             //use same buffer for write and read in this case
    if( Twi_writeBytes(buf, 2, false) &&       //no stop, so read will
        Twi_readBytes(buf, 2, true) ) {        //be a repeat start
        id = (buf[0]<<8) | buf[1];             //big endian to little endian
        //id was read ok
    }

}