IoT - Modular - I2C.cpp - Revision history

Tinker: Created page with "==#includes, Defines, etc...== #include "libraries.h" #include "functions.h" ==I2C_Test()==
2021-04-30T03:26:50Z

Created page with "==#includes, Defines, etc...== <syntaxhighlight lang="cpp" line="1"> #include "libraries.h" #include "functions.h" </syntaxhighlight> ==I2C_Test()== <syntaxhighlight lang="..."

New page
==#includes, Defines, etc...==

<syntaxhighlight lang="cpp" line="1">
#include "libraries.h"
#include "functions.h"
</syntaxhighlight>

==I2C_Test()==

<syntaxhighlight lang="cpp" line="1">
bool I2C_Test(int SDA, int SCL)
{
debug_SectionTitle("I2C Test &/or repair...");

bool SCL_state = (digitalRead(SCL) == HIGH);
bool SDA_state = (digitalRead(SDA) == HIGH);

if (SCL_state && SDA_state)
{
debug_LineOut("I2C is good.");
return (true);
}
else
{
if (!SCL_state)
debug_Trouble("SCL is LOW.");
if (!SDA_state)
debug_Trouble("SDA is LOW.");
debug_Action("Clearing I2C");

switch (I2C_ClearBus(SDA, SCL))
{
case 0:
debug_LineOut("I2C is clear.");
return (true);
break;
case 1:
debug_Trouble("I2C bus error. Could not clear");
debug_Trouble("SCL clock line held low");
break;
case 2:
debug_Trouble("I2C bus error. Could not clear SCL clock");
debug_Trouble("line held low by slave clock stretch");
break;
case 3:
debug_Trouble("I2C bus error. Could not clear");
debug_Trouble("SDA data line held low");
break;
}
debug_Trouble("++++++++++++++++ STOPPING!!! +++++++++++++++++");
while (true) // Slam on da brakes!
blinkLED(100);
return (false);
}
}
</syntaxhighlight>

==I2C_ClearBus()==

<syntaxhighlight lang="cpp" line="1">
/**
* This routine turns off the I2C bus and clears it
* on return SCA and SCL pins are tri-state inputs.
* You need to call Wire.begin() after this to re-enable I2C
* This routine does NOT use the Wire library at all.
*
* returns 0 if bus cleared
* 1 if SCL held low.
* 2 if SDA held low by slave clock stretch for > 2sec
* 3 if SDA held low after 20 clocks.
*
* Source: http://www.forward.com.au/pfod/ArduinoProgramming/I2C_ClearBus/index.html
*/

int I2C_ClearBus(int SDA, int SCL)
{
#if defined(TWCR) && defined(TWEN)
TWCR &= ~(_BV(TWEN)); // Disable the Atmel 2-Wire interface
// so we can control the SDA and SCL pins directly
#endif

pinMode(SDA, INPUT_PULLUP); // Make SDA (data) and SCL (clock) pins Inputs with pullup.
pinMode(SCL, INPUT_PULLUP);

delay(2500); // Wait 2.5 secs. This is strictly only necessary on the first power
// up of the DS3231 module to allow it to initialize properly,
// but is also assists in reliable programming of FioV3 boards as it gives the
// IDE a chance to start uploaded the program
// before existing sketch confuses the IDE by sending Serial data.

boolean SCL_LOW = (digitalRead(SCL) == LOW); // Check is SCL is Low.
if (SCL_LOW)
{ //If it is held low Arduno cannot become the I2C master.
return 1; //I2C bus error. Could not clear SCL clock line held low
}

boolean SDA_LOW = (digitalRead(SDA) == LOW); // vi. Check SDA input.
int clockCount = 20; // > 2x9 clock

while (SDA_LOW && (clockCount > 0))
{ // vii. If SDA is Low,
clockCount--;
// Note: I2C bus is open collector so do NOT drive SCL or SDA high.
pinMode(SCL, INPUT); // release SCL pullup so that when made output it will be LOW
pinMode(SCL, OUTPUT); // then clock SCL Low
delayMicroseconds(10); // for >5uS
pinMode(SCL, INPUT); // release SCL LOW
pinMode(SCL, INPUT_PULLUP); // turn on pullup resistors again
// do not force high as slave may be holding it low for clock stretching.
delayMicroseconds(10); // for >5uS
// The >5uS is so that even the slowest I2C devices are handled.
SCL_LOW = (digitalRead(SCL) == LOW); // Check if SCL is Low.
int counter = 20;
while (SCL_LOW && (counter > 0))
{ // loop waiting for SCL to become High only wait 2sec.
counter--;
delay(100);
SCL_LOW = (digitalRead(SCL) == LOW);
}
if (SCL_LOW)
{ // still low after 2 sec error
return 2; // I2C bus error. Could not clear.
// SCL clock line held low by slave clock stretch for >2sec
}
SDA_LOW = (digitalRead(SDA) == LOW); // and check SDA input again and loop
}
if (SDA_LOW)
{ // still low
return 3; // I2C bus error. Could not clear. SDA data line held low
}

// else pull SDA line low for Start or Repeated Start
pinMode(SDA, INPUT); // remove pullup.
pinMode(SDA, OUTPUT); // and then make it LOW i.e. send an I2C Start or Repeated start control.
// When there is only one I2C master a Start or Repeat Start
// has the same function as a Stop and clears the bus.
// A Repeat Start is a Start occurring after a Start with
// no intervening Stop.
delayMicroseconds(10); // wait >5uS
pinMode(SDA, INPUT); // remove output low
pinMode(SDA, INPUT_PULLUP); // and make SDA high i.e. send I2C STOP control.
delayMicroseconds(10); // x. wait >5uS
pinMode(SDA, INPUT); // and reset pins as tri-state inputs which is the default state on reset
pinMode(SCL, INPUT);
return 0; // all ok
}
</syntaxhighlight>