//MyMCP3421.cpp
//Code fuer Arduino und Attiny85
//Author Retian
//Version 1.0

/*
Abfrage eines Analog/Digital-Wandlers MCP3421 ueber die I2C-Schnittstelle.

MyMCP3421 Name(I2C-Adresse);

Beispiel siehe unter:
https://arduino-projekte.webnode.at/meine-libraries/adc-mcp3421/

Funktionen siehe unter:
https://arduino-projekte.webnode.at/meine-libraries/adc-mcp3421/funktionen/

*/

//*************************************************************************
//*************************************************************************

#include "Arduino.h"
#include "MyMCP3421.h"

MyMCP3421::MyMCP3421()
{
  _i2cAdd = MCP3421_I2CADD_DEFAULT;
  Wire.begin();
}

MyMCP3421::MyMCP3421(byte i2cAdd)
{
  _i2cAdd  = i2cAdd;
  Wire.begin();
}

//*************************************************************************
//MCP3421 vorhanden ?

bool MyMCP3421::isReady()
{
  Wire.beginTransmission(_i2cAdd);
  if (Wire.endTransmission()== 0) return true;
  else return false;
}

//*************************************************************************
//Initialisieren des MCP3421

void MyMCP3421::init()
{
  //Setzen des Config-Register
  setMode(MCP3421_MODE_SINGLESHOT);
  setGain(MCP3421_PGA_2P048);
  setRate(MCP3421_RATE_3P75);
}

//*************************************************************************
//Setzen der Datenrate
//Interne Verwendung
//Die Library unterstuetzt nur 3.75 SPS bei 18 Bit Aufloesung

void MyMCP3421::setRate(byte rate)
{
  byte _rate = rate;

  readRegister();
  if (bitRead(_rate, 1)) configReg |= (1 << MCP3421_S1);
  else configReg &= ~(1 << MCP3421_S1);
  if (bitRead(_rate, 0)) configReg |= (1 << MCP3421_S0);
  else configReg &= ~(1 << MCP3421_S0);
  writeRegister(configReg);
}

//*************************************************************************
//Setzen der Verstaerkung des PGA

void MyMCP3421::setGain(byte gain)
{
  byte _gain = gain;
  
  readRegister();
  if (bitRead(_gain, 1)) configReg |= (1 << MCP3421_G1);
  else configReg &= ~(1 << MCP3421_G1);
  if (bitRead(_gain, 0)) configReg |= (1 << MCP3421_G0);
  else configReg &= ~(1 << MCP3421_G0);
  writeRegister(configReg);
  
  switch (_gain) {
    case MCP3421_PGA_2P048:
      bitNumbering = MCP3421_LSB_2P048;
      break;
    case MCP3421_PGA_1P024:
      bitNumbering = MCP3421_LSB_1P024;
      break;
    case MCP3421_PGA_0P512:
      bitNumbering = MCP3421_LSB_0P512;
      break;
    case MCP3421_PGA_0P256:
      bitNumbering = MCP3421_LSB_0P256;
      break;
  }
}

//*************************************************************************
//Abfragen der Verstaerkung des PGA

byte MyMCP3421::getGain()
{ 
  readRegister();
  return (configReg & 0b11);
}

//*************************************************************************
//Setzen des Betriebsmodus

void MyMCP3421::setMode(bool mode)
{
  bool _mode = mode;
  
  readRegister();
  if (_mode) configReg |= (1 << MCP3421_OC);
  else configReg &= ~(1 << MCP3421_OC);
  writeRegister(configReg);
}

//*************************************************************************
//Abfrage des Betriebmodus

byte MyMCP3421::getMode()
{
  readRegister();
  return (configReg & 0b10000) >> 4;
}

//*************************************************************************
//Starten einer Einzelmessung (single-shot mode)

void MyMCP3421::startSingleMeas()
{
  if (getMode() != MCP3421_MODE_SINGLESHOT) setMode(MCP3421_MODE_SINGLESHOT);
  else readRegister();
  configReg |= (1 << MCP3421_RDY);
  writeRegister(configReg);
}

//*************************************************************************
//Umwandlung fertig? (Nur fuer Singleshot-Mode)

bool MyMCP3421::conversionReady()
{
  bool convReady;
  
  readRegister();
  convReady = !(configReg >> 7);
  return convReady;
}

//*************************************************************************
//Lesen des Wandlungsergebnisses als 18-Bit Zahl

long MyMCP3421::readConversion()
{
  readRegister();
  return conversionReg;
}

//*************************************************************************
//Lesen des Wandlungsergebnisses als Spannungswert

float MyMCP3421::readVoltage()
{
  readRegister();
  return (conversionReg / 1000.0 * bitNumbering);
}

//*************************************************************************
//Ausgabe des Inhalts des Configuration-Register (nicht fuer Attiny)

void MyMCP3421::printConfigReg()
{
#if defined_ATtiny
#else
  readRegister();
  Serial.print("Conf.Reg.: ");
  Serial.println(configReg, BIN);
#endif
}

//*************************************************************************
//Schreiben des Config-Register
//Interne Verwendung

void MyMCP3421::writeRegister(byte reg)
{
  //Es kann nur das Config-Register beschrieben werden

  byte _reg = reg;

  Wire.beginTransmission(_i2cAdd);
  Wire.write(_reg);
  Wire.endTransmission();
}

//*************************************************************************
//Lesen des Conversion- und des Config-Register
//Interne Verwendung

void MyMCP3421::readRegister()
{
  //Es ist nicht moeglich, das Config-Register direkt auszulesen,
  //es muss immer auch das Conversion-Register ausgelesen werden
  
  conversionReg = 0;
  
  Wire.requestFrom((int)_i2cAdd, 4);
  delay(5);
  if (Wire.available())
  {
    conversionReg |= Wire.read();
    conversionReg <<= 8;
    conversionReg |= Wire.read();
    conversionReg <<= 8;
    conversionReg |= Wire.read();

    configReg = Wire.read();
  }
  if (conversionReg >> 23) conversionReg |= 0xFF000000;
}