Leitwert über MCP3221 messen

"""
Based on https://github.com/SparkysWidgets/MinipHBFW
A simple library to support http:#www.sparkyswidgets.com/Projects/MiniPh.aspx
on BeagleBone Black. Likely compatible with Raspbery Pi (minor changes might
be required). Requires SciPy and python-smbus.
Evan Galpin 2015
"""
import smbus as I2C
import pHParams
import time


class pHReader(object):
   """Reads values from the pH probe + MinipH and converts to pH
   """
   def __init__(self, addr=0x4D, busnum=-1):
       """Creates an pH Reader with a given address and on a specific I2C bus
       (if provided). If no bus number is provided, the default Adafruit_I2C
       bus will be selected (I2C2).
       :param addr: The address of the device on the I2C bus. This is the
       address of the MCP3221 of the MinipH. Use i2cdetect -y -r 0 and
       i2cdetect -y -r 1 to probe for connected devices. See
       https://learn.adafruit.com/setting-up-io-python-library-on-beaglebone-black/i2c
       for details and installation instructions.
       :param busnum: Optional. The I2C bus number that the probe is on.
       Default Adafruit_I2C bus (I2C2) used if not specified.
       """
       self.addr = addr
       self.i2c = I2C.SMBus(1)
       self.params = pHParams.pHParams()




   def read(self):
       """Read and assemble the 12-bit reading from the MCP3221 of the MinipH.
       :return : Integer between 0 and 4096 (2^12).
       """
       reading = self.i2c.read_i2c_block_data(self.addr, 0x00, 2)
       return (reading[0] << 8) + reading[1]




   def calc_ph(self, reading):
       """Calculates the pH based on millivolts reading from ADC of MinipH
       :param reading: Raw 12-bit reading from MinipH
       :return : Integer. 0.0 <= return <= 14.0
       """
       reading = reading - self.params.intercept
       return round(reading / self.params.slope, 2)




def main():
   """Test function to ensure that your system is working properly and to
   obtain calibration readings.
   """
   phr = pHReader()
   while True:
       sample = phr.read()
       print sample
       print phr.calc_ph(sample)
       print
       time.sleep(1)




if __name__ == '__main__':
   main()

#!/usr/bin/perl


my $dir = '/var/www/motion';


$EC = `sudo i2cget -y 1 0x4a 0x00 w` ;


               $ECdec=hex($EC)/10;


               $rrd = `/usr/bin/rrdtool update $dir/homeec.rrd N:$ECdec`;




print "Electric Conductivity $ECdec µS/cm \n";

/////////////////////////////////////////////////////////////////////////////
/*!
This is a simple example showing how to interface our mini I2C eC interface.
The usage for this design is very simple, as it uses the MCP3221 I2C ADC. Although actual
eC calculation is done offboard.
MinieC can operate from 2.7 to 5.5V to accommodate varying levels of system. Power VCC with 3.3v for a raspi!


ADC samples at ~28.8KSPS @12bit (4096 steps) and has 8 I2C address of from A0 to A7 (Default A5)
simply assemble the 2 BYTE registers from the standard I2C read for the raw reading.
conversion to pH shown in code.


Sparky's Widgets 2014
https://www.sparkyswidgets.com/portfolio-item/miniec-i2c-ec-interface/
I invest a lot of time and resources providing open source hardware, software, and tutorials
Please help support my efforts by purchasing products from www.sparkyswidgets.com, donating some time
on documentation or you can even donate some BitCoin to 1NwPNsf6t5vpph6AYY5bg361PSppPSSgDn
*/
/////////////////////////////////////////////////////////////////////////////




//I2C Library
#include <Wire.h>
//We'll want to save calibration and configration information in EEPROM
#include <avr/eeprom.h>
#include <MCP3221.h>
//EEPROM trigger check
#define Write_Check      0x1234


byte i2cAddress = 0x4D; // MCP3221 A5 in Dec 77 A0 = 72 A7 = 79)
// A0 = x48, A1 = x49, A2 = x4A, A3 = x4B, 
// A4 = x4C, A5 = x4D, A6 = x4E, A7 = x4F


//Our parameter, for ease of use and eeprom access lets use a struct
struct parameters_T
{
 unsigned int WriteCheck;
 int eCLowCal, eCHighCal;
 float eCStep;
}
params;


float eC, temperatute;
const int I2CadcVRef = 4948;
const int oscV = 185; //voltage of oscillator output after voltage divider in millivolts i.e 120mV (measured AC RMS) ideal output is about 180-230mV range   
const float kCell = 1.0; //set our Kcell constant basically our microsiemesn conversion 10-6 for 1 10-7 for 10 and 10-5 for .1
const float Rgain = 3000.0; //this is the measured value of the R9 resistor in ohms


MCP3221 i2cADC(i2cAddress, I2CadcVRef);


void setup()
{
 Wire.begin(); //connects I2C
 Serial.begin(9600);
 //Lets read our Info from the eeprom and setup our params,
 //if we loose power or reset we'll still remember our settings!
 eeprom_read_block(&params, (void *)0, sizeof(params));
 //if its a first time setup or our magic number in eeprom is wrong reset to default
 if (params.WriteCheck != Write_Check){
   reset_Params();
 }
}


void loop()
{
int adcRaw = i2cADC.calcRollingAVG();
calcEc(adcRaw);
}




//Lets read our raw reading while in our lower eC cal solution
void calibrateeCLow(int calnum)
{
 params.eCLowCal = calnum;
 calceCSlope();
 //write these settings back to eeprom
 eeprom_write_block(&params, (void *)0, sizeof(params)); 
}


//Lets read our raw reading while in our higher eC cal solution
void calibrateeCHigh(int calnum)
{
 params.eCHighCal = calnum;
 calceCSlope();
 //write these settings back to eeprom
 eeprom_write_block(&params, (void *)0, sizeof(params));
}


//This is really the heart of the calibration process
void calceCSlope ()
{
 //RefVoltage * our deltaRawpH / 12bit steps *mV in V / OP-Amp gain /pH step difference 7-4
params.eCStep = ((((I2CadcVRef*(float)(params.eCLowCal - params.eCHighCal)) / 4095) * 1000));
}




void calcEc(int raw)
{
float temp, tempmv, tempgain, Rprobe;
tempmv = (float)i2cADC.calcMillivolts(raw);
tempgain = (tempmv / (float)oscV) - 1.0; // what is our overall gain again so we can cal our probe leg portion
Rprobe = (Rgain / tempgain); // this is our actually Resistivity
temp = ((1000000) * kCell) / Rprobe; // this is where we convert to uS inversing so removed neg exponant
eC = temp / 1000.0; //convert to EC from uS
}


//This just simply applies defaults to the params incase the need to be reset or
//they have never been set before (!magicnum)
void reset_Params(void)
{
 //Restore to default set of parameters!
 params.WriteCheck = Write_Check;
 params.eCLowCal = 200; //assume ideal probe and amp conditions 1/2 of 4096
 params.eCHighCal = 1380; //using ideal probe slope we end up this many 12bit units away on the 4 scale
 eeprom_write_block(&params, (void *)0, sizeof(params)); //write these settings back to eeprom
}
Status API Training Shop Blog About
© 2016 GitHub, Inc. Terms Privacy Security Contact Help