Home    Impressum / Datenschutz    Shop    Download    Links     Blog  

Ansteuerung der I2C-Komponenten mit Arduino

Temperatur vom LM75 lesen sowie Analogwert vom PCF8591 lesen und schreiben mit dem Arduino-Board

 

Die Entwicklungsumgebung für das Arduino-Board kann auf der Arduino Seite heruntergeladen werden http://www.arduino.cc/en/Main/Software

 Zitat:

Hallo,

anbei mein Beitrag wo ich Ihren LM75 Temperatursensor mit dem Arduino-Board angesprochen habe.

Es sind alle Funktionen inkludiert.

Liebe Grüße
Robert J.

Arduino-Code "arduino_lm75.txt"

// Anschluß eines I²C-Temperatursensor mit LM75 von Horter & Kalb an Arduino
// Bei den meisten Arduinos befindet sich der SDA (data line) an Analog Bin 4 und SCL (Clock line) an Analog Bin 5,
// bei Arduino Mega SDA an digital Pin 20 und SCL an digital Pin 21
// I2C wird über die Wire Library abgewickelt. Der angegebene Code ist für die Version 1.0 des Arduino Compilers (nächste nach 23)
// In dieser Version wurde durch Vererbung von Streams.h die Funktion Wire.send durch die Funktion Wire.write ersetzt.
// Darauf ist zu achten, wenn man in einer älteren Version compiliert.
// Es wurden alle Funktionen eingebaut und als Beispiel angeführt.
// Liest man nur die Temperatur aus, so kann auf den Großteil verzichtet werden.

#include <Wire.h>
#define SensorAdresse 0x48 // Basisadresse für ersten Temperatursensor

// Registerparameter fuer get_LM75_temperature
#define TEMP 0  // Temperaturregister anwählen
#define UNTEN 2 // Register für den unteren Schaltwert anwählen
#define OBEN 3  // Register für den oberen Schaltwert anwählen

// LM75 Configuration Register Registeradresse: 1
// Bit 0: Stromsparmodus, bei 1 geht Temperatursensor in den Stromsparmodus (keine Messung, aber aktive Steuerung) Ausgang wird auch abgeschaltet
//                        bei 0 geht Temperatursensor aus dem Stromsparmodus (Messung) Ausgang wird wieder freigegeben  
// Bit 1: Interrupt Modus, bei 1 schaltet der Ausgang sowohl bei oberen als auch unteren Schwellwert ein, wird zurückgesetzt durch Auslesen des Registers
//                         bei 0 schaltet der Ausgang bei oberen Schaltpunkt ein und bei unteren aus (default 80°C / 75°C)
// Bit 2: OS-Pin bei 1 wird das Verhalten des Ausgangs invertiert, Ausgang ist eingeschalten innerhalb der Schwellwerte
//               bei 0 Ausgang schaltet bei Überschreiten der eingestellten Schwellwerte
// Bit 3 und 4: Wert 0-3, besagt wieviele Messzyklen abgewartet wird, bis Ausgang aktiv/inaktiv wird, wenn die Bedingung erfüllt ist (verhindert Flattern des Ausgangs)
// Bit 5-7 müssen 0 sein
// Byte: 7 6 5 4 3 2 1 0

char dataString[7]; // gelesene Temperatur als String aufbereitet: (-xx)x.x
double temp; // gelesene Temperatur als double

void setup() {
  Wire.begin();
  Serial.begin(9600);
  delay(1000);
}

void loop()  
{  
// Temperatur aus LM75 auslesen
  temp = get_LM75_temperature(0, TEMP); //(Device)Wert vom 1. Temperatursensor lesen (0-7, je nach Jumperstellung am Board, 2. Parameter wie oben definiert)
  dtostrf(temp, 4, 1, dataString); //dtostrf(floatVar, minStringWidthIncDecimalPoint, numVarsAfterDecimal, charBuf); (standard avr-libc function)
  Serial.print("Gemessene Temperatur: ");
  Serial.println(dataString);
 
// LM75 Konfigurationsregister auslesen: Device
  Serial.print("Konfigurations-Register: ");
  Serial.println(get_LM75_config(0), HEX);
 
// LM75 Konfigurationsregister setzen: Device, Wert siehe oben
  set_LM75_config(0, 0);
 
// LM75 Schaltwerte setzen: Device, Register, Wert als double
  set_LM75_schaltwert(0, UNTEN, 26);
  set_LM75_schaltwert(0, OBEN, 28.5);
 
// LM75 Schaltwerte auslesen: Device, Register
  temp = get_LM75_temperature(0, UNTEN);
  Serial.print("UNTEN: ");
  Serial.println(temp, 1);
  temp = get_LM75_temperature(0, OBEN);
  Serial.print("OBEN: ");
  Serial.println(temp,1);
  delay(5000);
}

// LM75 Temperatur auslesen. Device = 0-7, regx = TEMP, OBEN, UNTEN (Registerauswahl)  
double get_LM75_temperature(int device, int regx)
{
  int8_t msb;
  int8_t lsb;
  int8_t msb1;
  Wire.beginTransmission(SensorAdresse + device);
  Wire.write(regx);
  Wire.endTransmission();
  Wire.beginTransmission(SensorAdresse + device);
  Wire.requestFrom(SensorAdresse + device, 2);
  if (Wire.available()) {
     msb1 = Wire.read();
     msb = msb1 << 1; // Vorzeichenbit entfernen, verbliebener Wert ist nun doppelt so groß
     lsb = Wire.read();
  }
  // höchstes bit von lsb sagt aus, ob 0,5 Grad dazu addiert werden sollen
  lsb = (lsb & 0x80 ) >> 7; // nun ist lsb = 0 oder 1
  Wire.endTransmission();
  if (msb1 < 0x80) { // Positiver Wert?
    return double(msb + lsb)/2; // positiver Wert
  }  
  else {
    return double(msb + lsb)/2 - 128; // negativer Wert
  }  
}

// LM75 Konfigurationsregister setzen, Werte wie oben definiert
void set_LM75_config(int device, byte value)
{
  Wire.beginTransmission(SensorAdresse + device);
  Wire.write(1); // Select Konfigurationsregister
  Wire.write(value);
  Wire.endTransmission();
}

// LM75 Konfigurationsregister auslesen, device = 0-7
byte get_LM75_config(int device)
{
  byte reg;
  Wire.beginTransmission(SensorAdresse + device);
  Wire.write(1); // Select Konfigurationsregister
  Wire.endTransmission();
  Wire.requestFrom(SensorAdresse + device, 1);
  if (Wire.available()) {
     reg = Wire.read();
  }
  Wire.endTransmission();
  return reg;
}

// LM75 Schaltwerte setzen, device = 0-7, regx = Wert, Grad als double
void set_LM75_schaltwert(int device, byte regx, double grad)
{
  int8_t msb;
  int8_t lsb = 0;
  uint8_t y = 0;
  boolean neg = false;
  if (grad < 0) {
    msb = abs(int(grad))+128;
  }
  else {  
    msb = abs(int(grad));
  }
  if (grad - abs(int(grad)) > 0) {
    lsb = 0x80;
  }
  Wire.beginTransmission(SensorAdresse + device);
  Wire.write(regx); // Selektiere oberes oder unteres Register
  Wire.write(msb);
  Wire.write(lsb);
  Wire.endTransmission();
}

 
 

 

 Zitat:

Sehr geehrter Herr Horter

Ich hatte bei Ihnen die PCF8591-Karte bezogen.
Mit einem Arduino 2009 habe ich AD- und DA-Umsetzer betrieben.
Das Programm lege ich Ihnen bei.

Viele Grüsse
Claus K.
 

Arduino-Code "arduino_pcf8591.txt "

// Title        : ADDA-Umsetzer mit PCF8591
// Micro        : Arduino 2009 w/ ATmega328
//
// -----------------------------------------------------------------------------------------
// Verbindungen I2C-Analog - Arduino
//             SCL     SDA     GND     +5V
// I2C-Analog  ST1-SCL ST1-SDA ST1-GND ST1-5V
// Arduino     A5      A4      GND     5

#include <Wire.h>
#define PCF8591 (0x9E >> 1)      

// Deviceadresse = 7
#define PCF8591_DAC_ENABLE 0x40
#define PCF8591_ADC_CH0 0x40
#define PCF8591_ADC_CH1 0x41
#define PCF8591_ADC_CH2 0x42
#define PCF8591_ADC_CH3 0x43
#define PURPOSE "Test of PCF8591"

const byte LED = 13;
byte adc_value, dac_value=0;
void putDAC(byte dac_value)
{
  Wire.beginTransmission(PCF8591);
  Wire.send(PCF8591_DAC_ENABLE);
  Wire.send(dac_value);
  Wire.endTransmission();
}
byte getADC(byte config)
{
  Wire.beginTransmission(PCF8591);
  Wire.send(config);
  Wire.endTransmission();
 
  Wire.requestFrom((int) PCF8591,2);
  while (Wire.available())
  {
    adc_value = Wire.receive();
    adc_value = Wire.receive();
  }
  return adc_value;
}
void setup()
{
  pinMode(LED, OUTPUT);
  Serial.begin(19200);
  Wire.begin();
  Serial.println(PURPOSE);
  Serial.println("DAC\tADC\tADC-DAC");
}
void loop()
{
  putDAC(dac_value);                      // DAC Wert setzen
  digitalWrite(LED, 1);                   // LED ein
  delay(10);
  adc_value = getADC(PCF8591_ADC_CH0);    // ADC Wert von Kanal0 auslesen
  digitalWrite(LED, 0);                   // LED aus
  Serial.print(dac_value, HEX);          // DAC Wert ausgeben
  Serial.print("\t");
  Serial.print(adc_value, HEX);          // ADC Wert ausgeben
  Serial.print("\t");
  Serial.println(dac_value - adc_value);  // Abweichung berechnen und ausgeben
  dac_value++;
  delay(200);
}

 

 

Arduino Quellcode Beispiele
arduino_lm75.txt (6kB)
Arduino Quellcode  mit einem Beispiel zum I2C Temperatursensor mit LM75
(Bitte mit der rechten Maustaste "speichern unter" wählen! )
arduino_pcf8591.txt (3kB)
Arduino Quellcode  mit einem Beispiel zur I2C Analogkarte mit PCF8591
(Bitte mit der rechten Maustaste "speichern unter" wählen! )

 


 
Bausätze können Sie günstig in unserem Onlineshop in der Rubrik
"I2C-Komponenten" bestellen.