BH1730 erstmal gelöscht

lib/Sensoren/BH1750.cpp

@@ -0,0 +1,29 @@
+
+#include <Arduino.h>
+
+#include "myi2c.h"
+#include "bh1750.h"
+
+
+
+//-------------------------------------------------
+// Power Up and start Messung
+void BH1750_Init(void)   
+{
+// BH1750 = HY30 Licht Sensor
+Set_I2C_Adresse(BH1750_ADR);  // GY-30 = 0x23
+I2C_write8A( 1); // Power On
+I2C_write8A( 0x20); // Start 1 lux Wandlung 120ms
+delay(180);
+}
+//-------------------------------------------------
+// Raed an Power Down
+unsigned int BH1750_ReadLux( void )
+{
+unsigned int uiLux;
+
+ uiLux = I2C_read16A()*10L/12;
+ I2C_write8A( 0); // Power Down
+return( uiLux);
+}
+//------------------------------------------------

lib/Sensoren/BH1750.h

@@ -0,0 +1,14 @@
+#ifndef _BH1750_H_
+#define _BH1750_H_
+
+
+ #include <Arduino.h>
+
+#define BH1750_ADR 0x23
+
+void BH1750_Init(void);
+unsigned int BH1750_ReadLux( void );
+
+
+
+#endif 

lib/Sensoren/bme280.cpp

@@ -0,0 +1,115 @@
+#include "Arduino.h"
+#include <Wire.h> 
+
+#include "myI2c.h" 
+#include "BME280.h" 
+
+
+bme280_calib_data _bme280_calib;
+int32_t t_fine;
+
+
+
+//-------------------------------------------------
+void bme280_readCoefficients(void)
+{
+    _bme280_calib.dig_T1 = I2C_read16_LE(BME280_REGISTER_DIG_T1);
+    _bme280_calib.dig_T2 = I2C_readS16_LE(BME280_REGISTER_DIG_T2);
+    _bme280_calib.dig_T3 = I2C_readS16_LE(BME280_REGISTER_DIG_T3);
+
+    _bme280_calib.dig_P1 = I2C_read16_LE(BME280_REGISTER_DIG_P1);
+    _bme280_calib.dig_P2 = I2C_readS16_LE(BME280_REGISTER_DIG_P2);
+    _bme280_calib.dig_P3 = I2C_readS16_LE(BME280_REGISTER_DIG_P3);
+    _bme280_calib.dig_P4 = I2C_readS16_LE(BME280_REGISTER_DIG_P4);
+    _bme280_calib.dig_P5 = I2C_readS16_LE(BME280_REGISTER_DIG_P5);
+    _bme280_calib.dig_P6 = I2C_readS16_LE(BME280_REGISTER_DIG_P6);
+    _bme280_calib.dig_P7 = I2C_readS16_LE(BME280_REGISTER_DIG_P7);
+    _bme280_calib.dig_P8 = I2C_readS16_LE(BME280_REGISTER_DIG_P8);
+    _bme280_calib.dig_P9 = I2C_readS16_LE(BME280_REGISTER_DIG_P9);
+
+    _bme280_calib.dig_H1 = I2C_read8(BME280_REGISTER_DIG_H1);
+    _bme280_calib.dig_H2 = I2C_readS16_LE(BME280_REGISTER_DIG_H2);
+    _bme280_calib.dig_H3 = I2C_read8(BME280_REGISTER_DIG_H3);
+    _bme280_calib.dig_H4 = (I2C_read8(BME280_REGISTER_DIG_H4) << 4) | (I2C_read8(BME280_REGISTER_DIG_H4+1) & 0xF);
+    _bme280_calib.dig_H5 = (I2C_read8(BME280_REGISTER_DIG_H5+1) << 4) | (I2C_read8(BME280_REGISTER_DIG_H5) >> 4);
+    _bme280_calib.dig_H6 = (int8_t)I2C_read8(BME280_REGISTER_DIG_H6); 
+    
+} 
+//-------------------------------------------------------------
+float bme280_readTemperature(void)
+{
+  int32_t var1, var2;
+  
+  int32_t adc_T = I2C_Read24(BME280_REGISTER_TEMPDATA);
+  adc_T >>= 4;
+
+  var1  = ((((adc_T>>3) - ((int32_t)_bme280_calib.dig_T1 <<1))) *
+     ((int32_t)_bme280_calib.dig_T2)) >> 11;
+
+  var2  = (((((adc_T>>4) - ((int32_t)_bme280_calib.dig_T1)) *
+       ((adc_T>>4) - ((int32_t)_bme280_calib.dig_T1))) >> 12) *
+     ((int32_t)_bme280_calib.dig_T3)) >> 14;
+
+  t_fine = var1 + var2;
+
+  float T  = (t_fine * 5 + 128) >> 8;
+  return T/100;
+} 
+//---------------------------------------------------
+float bme280_readPressure(void)
+{
+  int64_t var1, var2, p;
+  
+
+  // Must be done first to get the t_fine variable set up
+  bme280_readTemperature();
+
+  int32_t adc_P = I2C_Read24(BME280_REGISTER_PRESSUREDATA);
+  adc_P >>= 4;
+
+  var1 = ((int64_t)t_fine) - 128000;
+  var2 = var1 * var1 * (int64_t)_bme280_calib.dig_P6;
+  var2 = var2 + ((var1*(int64_t)_bme280_calib.dig_P5)<<17);
+  var2 = var2 + (((int64_t)_bme280_calib.dig_P4)<<35);
+  var1 = ((var1 * var1 * (int64_t)_bme280_calib.dig_P3)>>8) +
+    ((var1 * (int64_t)_bme280_calib.dig_P2)<<12);
+  var1 = (((((int64_t)1)<<47)+var1))*((int64_t)_bme280_calib.dig_P1)>>33;
+
+  if (var1 == 0) {
+    return 0;  // avoid exception caused by division by zero
+  }
+  p = 1048576 - adc_P;
+  p = (((p<<31) - var2)*3125) / var1;
+  var1 = (((int64_t)_bme280_calib.dig_P9) * (p>>13) * (p>>13)) >> 25;
+  var2 = (((int64_t)_bme280_calib.dig_P8) * p) >> 19;
+
+  p = ((p + var1 + var2) >> 8) + (((int64_t)_bme280_calib.dig_P7)<<4);
+  return (float)p/256;
+}
+//----------------------------------------------------------
+float bme280_readHumidity(void) 
+{
+  bme280_readTemperature(); // must be done first to get t_fine
+
+  int32_t adc_H = I2C_read16(BME280_REGISTER_HUMIDDATA);
+
+  int32_t v_x1_u32r;
+
+  v_x1_u32r = (t_fine - ((int32_t)76800));
+
+  v_x1_u32r = (((((adc_H << 14) - (((int32_t)_bme280_calib.dig_H4) << 20) -
+      (((int32_t)_bme280_calib.dig_H5) * v_x1_u32r)) + ((int32_t)16384)) >> 15) *
+         (((((((v_x1_u32r * ((int32_t)_bme280_calib.dig_H6)) >> 10) *
+        (((v_x1_u32r * ((int32_t)_bme280_calib.dig_H3)) >> 11) + ((int32_t)32768))) >> 10) +
+      ((int32_t)2097152)) * ((int32_t)_bme280_calib.dig_H2) + 8192) >> 14));
+
+  v_x1_u32r = (v_x1_u32r - (((((v_x1_u32r >> 15) * (v_x1_u32r >> 15)) >> 7) *
+           ((int32_t)_bme280_calib.dig_H1)) >> 4));
+
+  v_x1_u32r = (v_x1_u32r < 0) ? 0 : v_x1_u32r;
+  v_x1_u32r = (v_x1_u32r > 419430400) ? 419430400 : v_x1_u32r;
+  float h = (v_x1_u32r>>12);
+  return  h / 1024.0;
+} 
+
+

lib/Sensoren/bme280.h

@@ -0,0 +1,74 @@
+#define BME280_ADR 0x76
+
+enum
+    {
+      BME280_REGISTER_DIG_T1              = 0x88,
+      BME280_REGISTER_DIG_T2              = 0x8A,
+      BME280_REGISTER_DIG_T3              = 0x8C,
+
+      BME280_REGISTER_DIG_P1              = 0x8E,
+      BME280_REGISTER_DIG_P2              = 0x90,
+      BME280_REGISTER_DIG_P3              = 0x92,
+      BME280_REGISTER_DIG_P4              = 0x94,
+      BME280_REGISTER_DIG_P5              = 0x96,
+      BME280_REGISTER_DIG_P6              = 0x98,
+      BME280_REGISTER_DIG_P7              = 0x9A,
+      BME280_REGISTER_DIG_P8              = 0x9C,
+      BME280_REGISTER_DIG_P9              = 0x9E,
+
+      BME280_REGISTER_DIG_H1              = 0xA1,
+      BME280_REGISTER_DIG_H2              = 0xE1,
+      BME280_REGISTER_DIG_H3              = 0xE3,
+      BME280_REGISTER_DIG_H4              = 0xE4,
+      BME280_REGISTER_DIG_H5              = 0xE5,
+      BME280_REGISTER_DIG_H6              = 0xE7,
+
+      BME280_REGISTER_CHIPID             = 0xD0,
+      BME280_REGISTER_VERSION            = 0xD1,
+      BME280_REGISTER_SOFTRESET          = 0xE0,
+
+      BME280_REGISTER_CAL26              = 0xE1,  // R calibration stored in 0xE1-0xF0
+
+      BME280_REGISTER_CONTROLHUMID       = 0xF2,
+      BME280_REGISTER_CONTROL            = 0xF4,
+      BME280_REGISTER_CONFIG             = 0xF5,
+      BME280_REGISTER_PRESSUREDATA       = 0xF7,
+      BME280_REGISTER_TEMPDATA           = 0xFA,
+      BME280_REGISTER_HUMIDDATA          = 0xFD,
+    }; 
+
+// CALIBRATION DATA
+    
+    typedef struct
+    {
+      uint16_t dig_T1;
+      int16_t  dig_T2;
+      int16_t  dig_T3;
+
+      uint16_t dig_P1;
+      int16_t  dig_P2;
+      int16_t  dig_P3;
+      int16_t  dig_P4;
+      int16_t  dig_P5;
+      int16_t  dig_P6;
+      int16_t  dig_P7;
+      int16_t  dig_P8;
+      int16_t  dig_P9;
+
+      uint8_t  dig_H1;
+      int16_t  dig_H2;
+      uint8_t  dig_H3;
+      int16_t  dig_H4;
+      int16_t  dig_H5;
+      int8_t   dig_H6;
+    } bme280_calib_data; 
+
+
+void bme280_readCoefficients(void);
+float bme280_readTemperature(void);
+float bme280_readPressure(void); 
+float bme280_readHumidity(void); 
+
+
+
+

lib/Sensoren/myI2C.cpp

@@ -0,0 +1,119 @@
+#include "Arduino.h"
+#include <Wire.h> 
+
+uint8_t _i2caddr;
+
+//-----------------------------------
+void Set_I2C_Adresse(uint8_t I2C_Adr)
+{
+ _i2caddr = I2C_Adr; 
+ //Wire.setClock(10000);
+}
+
+
+//--------------------------------------------------
+uint8_t I2C_read8(byte reg)
+{
+  uint8_t value;
+  
+    Wire.beginTransmission((uint8_t)_i2caddr);
+    Wire.write((uint8_t)reg);
+    Wire.endTransmission();
+    Wire.requestFrom((uint8_t)_i2caddr, (byte)1);
+    value = Wire.read();
+
+  return value;
+} 
+//----------------------------------------------
+void I2C_write8(byte reg, byte value)
+{
+    Wire.beginTransmission((uint8_t)_i2caddr);
+    Wire.write((uint8_t)reg);
+    Wire.write((uint8_t)value);
+    Wire.endTransmission();
+} 
+//---------------------------------------------
+
+// 8bit ohne Register schreiben
+void I2C_write8A(byte value)
+{
+    Wire.beginTransmission((uint8_t)_i2caddr);    
+    Wire.write((uint8_t)value);
+    Wire.endTransmission();
+} 
+//---------------------------------------------
+uint16_t I2C_read16(byte reg)
+{
+  uint16_t value;
+ 
+    Wire.beginTransmission((uint8_t)_i2caddr);
+    Wire.write((uint8_t)reg);
+    Wire.endTransmission();
+    Wire.requestFrom((uint8_t)_i2caddr, (byte)2);
+    value = (Wire.read() << 8) | Wire.read();
+
+  return value;
+}
+//------------------------------------------
+// 16 bit lesen ohne Register
+uint16_t I2C_read16A(void)
+{
+  uint16_t value;
+ 
+    Wire.beginTransmission((uint8_t)_i2caddr);
+    Wire.requestFrom((uint8_t)_i2caddr, (byte)2);
+    value = (Wire.read() << 8) | Wire.read();
+
+  return value;
+}
+//------------------------------------------
+
+int16_t I2C_readS16(byte reg)
+{
+  return (int16_t)I2C_read16(reg);
+}
+//---------------------------------------------
+uint16_t I2C_read16_LE(byte reg) 
+{
+  uint16_t temp = I2C_read16(reg);
+  return (temp >> 8) | (temp << 8);
+
+} 
+//------------------------------------------
+int16_t I2C_readS16_LE(byte reg)
+{
+  return (int16_t)I2C_read16_LE(reg);
+
+}  
+//----------------------------------------------
+uint32_t I2C_Read24(byte reg)
+{
+  uint32_t value;
+
+    Wire.beginTransmission((uint8_t)_i2caddr);
+    Wire.write((uint8_t)reg);
+    Wire.endTransmission();
+    Wire.requestFrom((uint8_t)_i2caddr, (byte)3);
+    
+    value = Wire.read();
+    value <<= 8;
+    value |= Wire.read();
+    value <<= 8;
+    value |= Wire.read();
+
+  return value;
+} 
+//--------------------------
+uint8_t I2C_Test(byte adr)
+{
+  uint8_t value;
+  
+    Wire.beginTransmission((uint8_t)adr);
+    Wire.write((uint8_t)0);
+    Wire.endTransmission();
+    Wire.requestFrom((uint8_t)adr, (byte)1);
+    value = Wire.read();
+
+  return value;
+} 
+//----------------------------------------------

lib/Sensoren/myI2C.h

@@ -0,0 +1,20 @@
+
+void Set_I2C_Adresse(uint8_t I2C_Adr);
+
+uint8_t I2C_read8(byte reg);
+void I2C_write8(byte reg, byte value);
+
+uint16_t I2C_read16(byte reg);
+int16_t I2C_readS16(byte reg);
+int16_t I2C_readS16_LE(byte reg);
+int16_t I2C_readS16_LE(byte reg);
+uint16_t I2C_read16_LE(byte reg) ;
+uint32_t I2C_Read24(byte reg);
+
+void I2C_write8A(byte value);
+uint16_t I2C_read16A(void);
+uint8_t I2C_Test(byte adr);
+
+extern uint8_t _i2caddr;
+
+

src/MessenSensoren.cpp

@@ -99,16 +99,8 @@ if ( i== 0x60)
  p = bme280_readPressure()/100.0;
  h = bme280_readHumidity();
  I2C_write8(BME280_REGISTER_CONTROL, 0x3C); // Sleep Mode
-*/
 
-// such BH1730
-if ( I2C_Test(0x29) != 0xFF )
-   {
-   BH1730_Init(); 
-   lVisLux = BH1730_ReadLux();
-   // BH1730_ReadIR();  will keiner mehr wissen
-   }
-   
+  
 // such BH1750
 if ( I2C_Test(0x23) != 0xFF )
    {

src/main.cpp

@@ -75,8 +75,6 @@ static const u1_t PROGMEM APPKEY[16] = {0xca, 0x96, 0x9a, 0x15, 0x76, 0x5d, 0xaf
 void os_getDevKey(u1_t *buf) { memcpy_P(buf, APPKEY, 16); }
 
 
-// hse-Protokoll Datensatz
-HseSP hse(2, 60);
 
 static uint8_t mydata[] = "Hello, world!";
 static osjob_t sendjob;
@@ -144,17 +142,6 @@ void printHex2(unsigned v) {
     Serial.print(v, HEX);
 }
 
-void Messen()
-{
-  hse.reset();
-  HseSP::ClimateSensor_t cs;
-  cs.Temperature = 22.2; //°C
-  cs.Humidity = 55.5;     //%
-  cs.Pressure = 1000.1;   //hPa
-  cs.Illuminance = 123;
-  hse.addClimateSensor(&cs);
-  
-}
 
 
 void do_send(osjob_t *j) {
@@ -163,7 +150,7 @@ void do_send(osjob_t *j) {
         Serial.println(F("OP_TXRXPEND, not sending"));
     } else {
         // Prepare upstream data transmission at the next possible time.
-        Messen();
+        MessenSensoren();
         uint8_t* buffer = hse.getBuffer();
         int size = hse.getSize();