INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
SHT21 in Sketch integrieren
06.04.2016, 10:07 (Dieser Beitrag wurde zuletzt bearbeitet: 06.04.2016 21:08 von Bitklopfer.)
Beitrag #1
SHT21 in Sketch integrieren
Hallo zusammen!

Ich hab folgendes Problem! Ich betreibe zuhause einen Homduino von Eugen.
HomeDuino
Mit dem Homeduino kann ich Sensorenwerte mir an Homematic übertragen lassen bzw von Homematic Schaltbefehle empfangen.
Leider ist Eugen ein sehr beschäftigter Mann und jetzt hoffe ich das mir hier jemand von euch helfen kann.
Ich würde gerne noch einen SHT21
http://arduinolearning.com/code/sht21-hu...xample.php
in den HomeDuino integrieren. Leider bekomme ich das nicht gebacken.
Ich hab in der Arduino IDE folgende Library hinzugefügt:
https://github.com/elechouse/SHT21_Arduino
und dann folgenden Beispiel-Sketch laufen lassen:
Code:
/****************************************************************
* ReadSHT2x
*  An example sketch that reads the sensor and prints the
*  relative humidity to the PC's serial port
*
*  Tested with:
*    - SHT21-Breakout Humidity sensor from elechouse.com

***************************************************************/
#include <Wire.h>
#include <SHT2x.h>


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

void loop()
{
  Serial.print("Humidity(%RH): ");
  Serial.print(SHT2x.GetHumidity());
  Serial.print("     Temperature(C): ");
  Serial.println(SHT2x.GetTemperature());
  
  delay(1000);
}


Im serial-Monitor wurden brav die Temperatur und die Luftfeuchte ausgegeben.
Also Modul und lib funktionieren.
Jetzt möchte ich das gerne im Sketch von Eugen integrieren.
Ich habe bereits Anpassungen vorgenommen, aber leider bekomme ich den Sketch nicht kombiliert.
Hier mal der angepasste Sketch:
Code:
const String Version = "hduino412_LAN";  /*Stand: 2015.09.07 / Verfasser: Eugen Stall
erprobt fuer Arduino Mega 2560 mit Arduino 1.6.5r2
hier ist immer die aktuelle Version:
http://www.stall.biz/project/homeduino-4-0-das-universelle-mess-und-aktormodul-fuer-die-hausautomation
das folgende homeduino-programm sendet messdaten zur ccu (homeduino als webclient) ...
und empfängt ausgabedaten für die homeduino-outputs (homeduino als webserver)
_________________            ________________
|port 8181 server|<---------<| client        |
|                |           |               |
| CCU            |           |     Homeduino |
|                |           |               |
|          client|>--------->|server port 80 |
|________________|           |_______________|

/Quellen:Arduino website plus http://arduino.cc/en/Tutorial/WebClient und ...
http://tushev.org/articles/arduino/item/52-how-it-works-ds18b20-and-arduino und ...  */
//################################################################################​#############
//################################################################################​#############
//Auswahl der verwendeten Shields:
#define tft_display //"tft_display" oder "lcd_display"                         <<user-eingabe<<
                    //"lcd_display" auch wenn kein display verwendet wird
#define w5100       //"cc3000"  Wifi-Modul oder "w5100" ethernet shield        <<user-eingabe<<

byte ccu[] = { 192, 168, 178, 50 };      //IP der CCU                          <<user-eingabe<<
//MAC-Adresse dieses Homeduinos ,bei mehreren Homeduinos MAC-.Adresse ändern!!:
byte mac[] = { 0xAC, 0xCC, 0xCC, 0xCC, 0xAC, 0xBC };  //                       <<user-eingabe<<

byte homeduino[] = { 192, 168, 178, 88 }; //IP des Homeduino,wenn DHCP versagt <<user-eingabe<<

char ap_ssid[] = "ssid"; //SSID WLAN in Anführungszeichen                      <<user-eingabe<<

char ap_password[] = "password"; //Passwort WLAN in Anführungszeichen          <<user-eingabe<<

//xyz ist indiv. Bezeichnung dieses homeduino, keine sonderzeichen, öäüß...
const String homeduino_nummer = "002";  //                                     <<user-eingabe<<
const String hm_systemvariable = "homeduino_" + homeduino_nummer +"_";
//################################################################################​#############
//################################################################################​#############
//I/O-Kennung: hier wird die Funktion aller verwendbaren IO´s mit einer Kennziffer festgelegt
//dabei haben alle IO´s die Standardfunktionen plus spez. Sonderfunktionen
//     Standardfunktionen sind:
//     '0' =andere Nutzg; '1' =dig_in; '2' =dig_out; '3' =1wire '4' =DHTxx; '5' =U_Schall

const byte iomodus_D[80] = { 0,0,
0, //D2 :      Std-fkt; '15' = IR_Rx??  '6' =ImpCount; '31' =tft;   <<user IO-Shield20<<
0, //D3 :      Std-fkt; '7' = 433_Rx??  '6' =ImpCount; '31' =tft;   <<user IO-Shield20<<
0, //D4 :      Std-fkt; '7' = 433_Tx??  '30' =lcd;     '31' =tft;   <<user IO-Shield20<<
0, //D5 :      Std-fkt;                 '30' =lcd;     '31' =tft;   <<user IO-Shield20<<
0, //D6 :      Std-fkt; '9' = buzzer    '30' =lcd;     '31' =tft;   <<user IO-Shield20<<
0, //D7 :      Std-fkt;                 '30' =lcd;     '31' =tft;   <<user IO-Shield20<<
0, //D8 :      Std-fkt;                 '30' =lcd;     '31' =tft;   <<user IO-Shield20<<
0, //D9 :      Std-fkt; '16' = IR_Tx??  '30' =lcd;     '31' =tft;   <<user IO-Shield20<<
20, //D10 :     Std-fkt; '20' = W5100 SS-Pin;
0,  //D11 :     Std-fkt;  
0,  //D12 :     Std-fkt;  
0,  //D13 :     Std-fkt;
0,  //D14/TX3 : Std-fkt; '0' =ESP8266;   '12' = rfid3;                <<user IO-Shield-Plus<<
0,  //D15/RX3 : Std-fkt; '0' =ESP8266;   '12' = rfid3;                <<user IO-Shield-Plus<<
0,  //D16/TX2 : Std-fkt; '0' =ESP8266;   '12' = rfid2;                <<user IO-Shield-Plus<<
0,  //D17/RX2 : Std-fkt; '0' =ESP8266;   '12' = rfid2;                <<user IO-Shield-Plus<<
0,  //D18/TX1 : Std-fkt; '6' =ImpCount;  '21' =CC3000                 <<user IO-Shield-Plus<<
0,  //D19/RX1 : Std-fkt; '6' =ImpCount;                               <<user IO-Shield-Plus<<
8,  //D20/SDA : Std-fkt; '6' =ImpCount;  '8' =I2C;                    <<user IO-Shield-Plus<<
8,  //D21/SCL : Std-fkt; '6' =ImpCount;  '8' =I2C;                    <<user IO-Shield-Plus<<
0,  //D22 :     Std-fkt; '12' = rfid3-oeffner;                        <<user IO-Shield-Plus<<
0,  //D23 :     Std-fkt; '12' = rfid2-oeffner;                        <<user IO-Shield-Plus<<
0,  //D24 :     Std-fkt;                                              <<user IO-Shield-Plus<<
0,  //D25 :     Std-fkt;                                              <<user IO-Shield-Plus<<
0,  //D26 :     Std-fkt;                                              <<user IO-Shield-Plus<<
0,  //D27 :     Std-fkt;                                              <<user IO-Shield-Plus<<
0,  //D28 :     Std-fkt;                                              <<user IO-Shield-Plus<<
0,  //D29 :     Std-fkt;                                              <<user IO-Shield-Plus<<
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
20, //MISO      '20' =W5100;  '21' =CC3000;   ICSP-Stecker
20, //MOSI      '20' =W5100;  '21' =CC3000;   ICSP-Stecker
20, //SCK       '20' =W5100;  '21' =CC3000;   ICSP-Stecker
0, //SS                      '21' =CC3000;
0, //D54 A0 :  Std-fkt; '10' =analog; '11' =NTC; '31' =tft; '30' =lcd; ser IO-Shield-20<<
0, //D55 A1 :  Std-fkt; '10' =analog; '11' =NTC; '31' =tft;         <<user IO-Shield-20<<
0, //D56 A2 :  Std-fkt; '10' =analog; '11' =NTC; '31' =tft;         <<user IO-Shield-20<<
0, //D57 A3 :  Std-fkt; '10' =analog; '11' =NTC; '31' =tft;         <<user IO-Shield-20<<
0, //D58 A4 :  Std-fkt; '10' =analog; '11' =NTC; '31' =tft;         <<user IO-Shield-20<<
0,  //D59 A5 :  Std-fkt; '10' =analog; '11' =NTC;                    <<user IO-Shield-20<<
0,0,  
0,  //D62 A8 :  Std-fkt; '10' =analog; '11' =NTC;                    <<user IO-Shield-Plus<<
0,  //D63 A9 :  Std-fkt; '10' =analog; '11' =NTC;                    <<user IO-Shield-Plus<<
0,  //D64 A10 : Std-fkt; '10' =analog; '11' =NTC;                    <<user IO-Shield-Plus<<
0,  //D65 A11 : Std-fkt; '10' =analog; '11' =NTC;                    <<user IO-Shield-Plus<<
0,  //D66 A12 : Std-fkt; '10' =analog; '11' =NTC;                    <<user IO-Shield-Plus<<
0,  //D67 A13 : Std-fkt; '10' =analog; '11' =NTC;                    <<user IO-Shield-Plus<<
0,  //D68 A14 : Std-fkt; '10' =analog; '11' =NTC;                    <<user IO-Shield-Plus<<
0,  //D69 A15 : Std-fkt; '10' =analog; '11' =NTC;                    <<user IO-Shield-Plus<<
0,  // '0' =andere Nutzg;    '8' =I2C;                               <<user IO-Shield-Plus<<
0,  // '0' =andere Nutzg;    '8' =I2C;                               <<user IO-Shield-Plus<<
0,  // '0' =andere Nutzg;    '8' =I2C;                               <<user IO-Shield-Plus<<
0,  // '0' =andere Nutzg;    '8' =I2C;                               <<user IO-Shield-Plus<<
0,  // '0' =andere Nutzg;                                            <<user IO-Shield-Plus<<
0,  // '0' =andere Nutzg;                                            <<user IO-Shield-Plus<<
0,  // '0' =andere Nutzg;                                            <<user IO-Shield-Plus<<
0,  // '0' =andere Nutzg;                                            <<user IO-Shield-Plus<<
0,  // '0' =andere Nutzg;                                            <<user IO-Shield-Plus<<
0,  // '0' =andere Nutzg;                                            <<user IO-Shield-Plus<<
};
//################################################################################​#############
//hier werden Sensoren am I2C-Eingang aktiviert
const byte iomodus_lux = 0; //'0' =nc; '1' =BMP180,                   <<user IO-Shield-Plus<<
const byte iomodus_sht =  1; //'0' =nc; '1' =SHT21,                   <<user IO-Shield-Plus<<
//################################################################################​#############
//hier werden die Kennwerte fuer die Impulszaehler festgelegt
volatile unsigned long pulsecounter[6] =
{ 0, //Zaehlerstand fuer D2 -Impulseingang bei Reset                    <<user IO-Shield20<<
0, //Zaehlerstand fuer D3 -Impulseingang bei Reset                     <<user IO-Shield20<<
0, //Zaehlerstand fuer D21-Impulseingang bei Reset                     <<user IO-Shield-Plus<<
3, //Zaehlerstand fuer D20-Impulseingang bei Reset                     <<user IO-Shield-Plus<<
4711, //Zaehlerstand fuer D19-Impulseingang bei Reset                  <<user IO-Shield-Plus<<
5 //Zaehlerstand fuer D18-Impulseingang bei Reset                      <<user IO-Shield-Plus<<
};
//hier wird der Teilerfaktor für die Impulszaehler festgelegt
const int pulsedivider[6] =
{6, //Teilerfaktor D2 :                                                 <<user IO-Shield20<<
1, //Teilerfaktor D3 :                                                 <<user IO-Shield20<<
1, //Teilerfaktor D21 :                                                <<user IO-Shield-Plus<<
1, //Teilerfaktor D20 :                                                <<user IO-Shield-Plus<<
2, //Teilerfaktor D19 :                                                <<user IO-Shield-Plus<<
1, //Teilerfaktor D18 :                                                <<user IO-Shield-Plus<<
};
//################################################################################​#############
//################################################################################​#############
//hier werden die anzeigetexte für lcd und tft display festgelegt
String display_message[80] = {
"0","0",         //                              '0' =keine anzeige
"beweg tuer:",  //anzeigetext fuer port D02
"beweg gart:",  //anzeigetext fuer port D03
"0","0","0","0","0","0",  // ports belegt durch lcd-shield    
"0",  // belegt durch ethernet W5100-shield, lcd-Shield PIN D10 abbiegen!
"11 Status :",  //anzeigetext fuer port D11                             <<user IO-Shield-20<<
"12 Status  ",  //anzeigetext fuer port D12                             <<user IO-Shield-20<<
"13 Status :",  //anzeigetext fuer port D13                             <<user IO-Shield-20<<
"14 Status :",  //anzeigetext fuer port D14 /TX3                        <<user IO-Shield-Plus<<
"RFID Tuer :",  //anzeigetext fuer port D15 /RX3                        <<user IO-Shield-Plus<<
"16 Status :",  //anzeigetext fuer port D16 /TX2                        <<user IO-Shield-Plus<<
"RFID Gara :",  //anzeigetext fuer port D17 /RX2                        <<user IO-Shield-Plus<<
"18 Status :",  //anzeigetext fuer port D18 /TX1 /impulszaehler S03     <<user IO-Shield-Plus<<
"19 gas/m3 :",  //anzeigetext fuer port D19 /RX1 /impulszaehler S02     <<user IO-Shield-Plus<<
"21 I2C SDA:",  //anzeigetext fuer port D20 /SDA /impulszaehler S01     <<user IO-Shield-Plus<<
"21 I2C SCL:",  //anzeigetext fuer port D21 /SCL /impulszaehler S00     <<user IO-Shield-Plus<<
"Offner Gara",  //anzeigetext fuer port D22                             <<user IO-Shield-Plus<<
"Offner Tuer",  //anzeigetext fuer port D23                             <<user IO-Shield-Plus<<
"24 Status  ",  //anzeigetext fuer port D24                             <<user IO-Shield-Plus<<
"25 Status :",  //anzeigetext fuer port D25                             <<user IO-Shield-Plus<<
"26 Status :",  //anzeigetext fuer port D26                             <<user IO-Shield-Plus<<
"27 Status :",  //anzeigetext fuer port D27                             <<user IO-Shield-Plus<<
"28 DS20B18:",  //anzeigetext fuer port D28                             <<user IO-Shield-Plus<<
"29 T_DHT22:",  //anzeigetext fuer port D29                             <<user IO-Shield-Plus<<
"0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0",
"0",  // port belegt durch lcd-shield
"Temp_auss.:",  //anzeigetext fuer port D55 /A1                         <<user IO-Shield-20<<
"Temp_innen:",  //anzeigetext fuer port D56 /A2                         <<user IO-Shield-20<<
"57 Status :",  //anzeigetext fuer port D57 /A3                         <<user IO-Shield-20<<
"58 Status :",  //anzeigetext fuer port D58 /A4                         <<user IO-Shield-20<<
"59 Spg_A5 :",  //anzeigetext fuer port D59 /A5                         <<user IO-Shield-20<<
"0","0",
"62 Status :",  //anzeigetext fuer port D62 /A8                         <<user IO-Shield-Plus<<
"63 Status :",  //anzeigetext fuer port D63 /A9                         <<user IO-Shield-Plus<<
"64 Status :",  //anzeigetext fuer port D64 /A10                        <<user IO-Shield-Plus<<
"65 Status :",  //anzeigetext fuer port D65 /A11                        <<user IO-Shield-Plus<<
"66 Status :",  //anzeigetext fuer port D66 /A12                        <<user IO-Shield-Plus<<
"67 Status :",  //anzeigetext fuer port D67 /A13                        <<user IO-Shield-Plus<<
"68 Status :",  //anzeigetext fuer port D68 /A14                        <<user IO-Shield-Plus<<
"Abstand/cm:",  //anzeigetext fuer port D69 /A15                        <<user IO-Shield-Plus<<
// die folgenden Anzeigetexte sind für Module mit mehreren Datenpunkten z.b. I2C-Module
"L-Druck/mB:",  //anzeigetext fuer I2C
"L-Temp./C :",  //anzeigetext fuer I2C
"Lux/lx    :",   //anzeigetext fuer I2C
"UV-Index  :",  //anzeigetext fuer I2C
"74 Status :",  //anzeigetext fuer
"75 Status :",  //anzeigetext fuer
"76 Status :",  //anzeigetext fuer
"77 Status :",  //anzeigetext fuer
"78 Status :",  //anzeigetext fuer
"79 Status :"   //anzeigetext fuer  
};
//################################################################################​#############
//################################################################################​#############
//hier werden die Zugangsberechtigungen für den RDM6300 Rfid-Reader und FOBs festgelegt
const byte fob_anzahl = 20;
const String fob[3*fob_anzahl] = {
"2381286","eugen","1",   // '0' = kein Tueroeffner                      <<user IO-Shield-Plus<<
"2381287","eugen","1",   // '1' = Tueroeffner1 D22                      <<user IO-Shield-Plus<<
"2381381","eugen","2",   // '2' = Tueroeffner2 D23                      <<user IO-Shield-Plus<<
"2380830","leonie","3",  // '3' = beide Tueroeffner                     <<user IO-Shield-Plus<<
"2409284","fabian","2"   //                                             <<user IO-Shield-Plus<<
"2409385","fabian","2"   //                                             <<user IO-Shield-Plus<<
"2409289","fabian","2"   //                                             <<user IO-Shield-Plus<<
"2519298","not used","0" //                                             <<user IO-Shield-Plus<<
"2519208","not used","0" //                                             <<user IO-Shield-Plus<<
"2519388","not used","0" //                                             <<user IO-Shield-Plus<<
"2519488","not used","0" //                                             <<user IO-Shield-Plus<<
"2511288","not used","0" //                                             <<user IO-Shield-Plus<<
"2529288","not used","0" //                                             <<user IO-Shield-Plus<<
"2619288","not used","0" //                                             <<user IO-Shield-Plus<<
"2719288","not used","0" //                                             <<user IO-Shield-Plus<<
"3519208","not used","0" //                                             <<user IO-Shield-Plus<<
"2519088","not used","0" //                                             <<user IO-Shield-Plus<<
"2519088","not used","0" //                                             <<user IO-Shield-Plus<<
"2510288","not used","0" //                                             <<user IO-Shield-Plus<<
"2510288","not used" "0" //                                             <<user IO-Shield-Plus<<
};
const unsigned long unlock_time1 = 5000; //oeffnungszeit rfid1 in ms    <<user IO-Shield-Plus<<
const unsigned long unlock_time2 = 5000; //oeffnungszeit rfid2 in ms    <<user IO-Shield-Plus<<
const boolean oeffner_polarity = 1;   // '1' normal, '0'  invers        <<user IO-Shield-Plus<<
//################################################################################​#############
//################################################################################​#############
//################################################################################​#############

#include <SPI.h>
#include <Wire.h>
#include <OneWire.h>   //für Temperatursensoren DS18B20
                       //http://www.hacktronics.com/code/OneWire.zip
#include <NewPing.h>   //für Ultraschallsensoren SR04
                       //https://arduino-new-ping.googlecode.com/files/NewPing_v1.5.zip
#include "DHT.h"       //für Temperatursensoren DHT22
                       //https://github.com/adafruit/DHT-sensor-library/archive/master.zip
#include <AS_BH1750.h> //für I2C-Luxmeter
                       //https://github.com/hexenmeister/AS_BH1750/archive/master.zip
#include <SFE_BMP180.h>//für I2C-Barometer
                       //https://github.com/sparkfun/BMP180_Breakout/archive/master.zip
#include <RCSwitch.h>  // läuft noch nicht!
#include <EEPROM.h>
#include <SHT2x.h>
//#include <IRremote.h>// läuft noch nicht!

//der folgende Bereich ist bei verwendung w5100 auszukommentieren
//ausblenden mit " #if defined (5100)" funktioniert leider nicht!!
/*
//Initialisierung des CC3000 Wifi auf dem IO-Shield-Plus  
#include <SFE_CC3000.h>// fuer cc3000 wifi
                 // http://github.com/sparkfun/SFE_CC3000_Library/archive/master.zip
#include <SFE_CC3000_Client.h>
// Pins
#define CC3000_INT 18  // int-Pin mit Wifi Shield ist D3, mit breakout auf IO-Shield-Plus D18
#define CC3000_EN 46   // en-Pin mit Wifi Shield ist D5, mit breakout auf IO-Shield-Plus  D46
#define CC3000_CS 53   // cs-Pin mit Wifi Shield ist D10, mit breakout auf IO-Shield-Plus D53
SFE_CC3000 wifi = SFE_CC3000(CC3000_INT, CC3000_EN, CC3000_CS);
SFE_CC3000_Client client = SFE_CC3000_Client(wifi);
unsigned int ap_security = WLAN_SEC_WPA2; // Security of network
unsigned int timeout = 30000; // Milliseconds
char server[] = "192,168,178,50"; // Remote host site
*/
#if defined (w5100)  //************************************************************************
//der folgende Bereich ist die Initialisierung des LAN bei Verwendung des LAN-Shields
#include <Ethernet.h>
EthernetClient client;
EthernetServer server(80);
#endif  //********************************************************************************​*****

#if defined(tft_display)  //*******************************************************************
#include <Adafruit_GFX.h>    //Quelle: https://github.com/adafruit/Adafruit-GFX-Library
#include <Adafruit_TFTLCD.h> //Quelle:   https://github.com/buhosoft/TFTLCD-Library
#include <stdint.h>
#include "TouchScreen.h"      
//Quelle: http://www.smokeandwires.co.nz/blog/a-2-4-tft-touchscreen-shield-for-arduino/
#define YP A1  // must be an analog pin, use "An" notation!
#define XM A2  // must be an analog pin, use "An" notation!
#define YM 7   // can be a digital pin
#define XP 6   // can be a digital pin
#define MINPRESSURE 10
#define MAXPRESSURE 1000
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 330);
#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0
#define tft_rotation 3 //3 oder 1 abhägig vom tft-shield typ               <<user-eingabe<<
#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
int touch_y;
const byte zeilenzahl = 6;
int px,py,pz;
boolean touch, touch_alt;
unsigned long next_touch_time = 0;


//2,4'' display
const long int px_A = 901,  py_A = 183;  //touch-koordinaten oben-links                
const long int px_B = 192,  py_B = 189;  //touch-koordinaten oben-rechts              
const long int px_C = 936,  py_C = 860;  //touch-koordinaten unten-links              
#define schriftgroesse 3
#define tft_type 1   // 1 ist 2,4''display   2 ist 3.95''display

//3,95'' display
//const long int px_A = 302, py_A = 890;  //touch-koordinaten oben-links              
//const long int px_B =280,  py_B = 115;  //touch-koordinaten oben-rechts            
//const long int px_C =842,  py_C = 900;  //touch-koordinaten unten-links              
//#define schriftgroesse 4  
//#define tft_type 2   // 1 ist 2,4''display   2 ist 3.95''display

long int p_x, p_y ;   //normierte aktuelle touch-koordinaten:
                      //oben links ist 0,0 und unten rechts ist 1000,1000
#endif  //********************************************************************************​*****

#if defined(lcd_display)  //*******************************************************************
//https://www.dfrobot.com/wiki/index.php?title=Arduino_LCD_KeyPad_Shield_%28SKU:_DFR0009%29
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // initialize library with numbers of the interface pins
const byte zeilenzahl = 2;
#endif  //********************************************************************************​*****

int x, x_alt;
byte zeile_pointer[6];
String zeile_data[6] = {"     ","     ","     ","     ","     ","     "};
String display_zeile_alt[6],display_zeile[6];
String taster;

char zeichen,buffer[50];
boolean fob_da =0;
String zeich, fob_hex, fob_dec,Name, lcd_rfid_message, oeffner, Value;
unsigned long fob_zahl,time_rfid3 = 0,time_rfid2 = 0;
byte zeichen_zahl;

//********************************************************************************​*************
AS_BH1750 sensor; //Initialize BH1750 Luxmeter library
float lux;
long Lux;
int laenge;
const float ALTITUDE = 299.0; // eigene seehoehe in metern              <<user IO-Shield-Plus<<
SHT2x.h sht;
SFE_BMP180 pressure;
char status;
float T,H,p0;
boolean reading = false;
String command = String(200);
String sht_string,shtT_string, lux_string;
//********************************************************************************​*************
boolean last_digital_value_D[80];
float last_value_D[80],last_IR_value,last_RF_value;
unsigned long next_Time[80];  
float last_sht_value,last_shtT_value;
boolean complete_loop =1; // wenn 1, dann einmal komplett durchlaufen
String befehl,sub_command = String(20),parameter = String(20),header = String(20);
int param,port_pin;
boolean port_data;
boolean value;
String I;
int analogwert;
//********************************************************************************​*************
float tempNTC;
const float B_wert = 3950; //aus dem Datenblatt des NTC //<<user-eingabe<<
const float Tn = 298.15; //25°Celsius in °Kelvin
const float Rv = 10000; //Vorwiderstand
const float Rn = 10000; //NTC-Widerstand bei 25°C
float Rt,temp_tur,humidity;

const float delta_onewire = 0.2; //Deltas für Sendeauslösung
const float delta_DHT = 0.2; //in °C
const float delta_us = 3.0; // in cm
const float delta_analog = 2.0; // in inkrement
const float delta_ntc = 0.5; //in °C
const float delta_lux = 15; //in lux
const float delta_counter = 5; //in counter inkrement
const float delta_sht = 0.2; //in %
const float delta_shtT = 0.2; //in °C

long duration, cm; //variable für Ultraschallsensor
unsigned long time_sr04;

unsigned long next_full_loop = 0;
unsigned long delta_time = 3600000; // jede Stunde werden alle Inputs aktualisiert
unsigned long delta_tx = 500; //in ms, minimaler Abstand der Telegramme an die CCU
unsigned long next_tx = 0, time_wait = 0;

int rf_key;
String rfkey;
RCSwitch mySwitch = RCSwitch();

unsigned zaehlwert;
unsigned last_zaehlwert[6] = {0,0,0,0,0,0};
//################################################################################​#############
//################################################################################​#############
void setup()
{Serial.begin(9600);
//+++++++ einrichtung der interrupts fuer impulszahler D2,D3,D18,D19,D20,D21
if ((pulsedivider[0] > 0) && (iomodus_D[2] == 6))
   {pinMode(2, INPUT_PULLUP); attachInterrupt(0, ISR_0, FALLING);}
if ((pulsedivider[1] > 0) && (iomodus_D[3] == 6))
   {pinMode(3, INPUT_PULLUP); attachInterrupt(1, ISR_1, FALLING);}
if ((pulsedivider[2] > 0) && (iomodus_D[21] == 6))
   {pinMode(21, INPUT_PULLUP); attachInterrupt(2, ISR_2, FALLING);}
if ((pulsedivider[3] > 0) && (iomodus_D[20] == 6))
   {pinMode(20, INPUT_PULLUP); attachInterrupt(3, ISR_3, FALLING);}
if ((pulsedivider[4] > 0) && (iomodus_D[19] == 6))
   {pinMode(19, INPUT_PULLUP); attachInterrupt(4, ISR_4, FALLING);}

#if defined (w5100)  //*************************************************************************
if ((pulsedivider[5] > 0) && (iomodus_D[18] == 6))  //interrupt reserviert fuer cc3000
   {pinMode(18, INPUT_PULLUP); attachInterrupt(5, ISR_5, FALLING);}
#endif  //********************************************************************************​*****

//+++++++ rfid initialisieren
if ((iomodus_D[15] == 12) && (iomodus_D[14] == 12)){Serial3.begin(9600);}
if ((iomodus_D[17] == 12) && (iomodus_D[16] == 12)){Serial2.begin(9600);}

#if defined (lcd_display)  //******************************************************************
//+++++++ lcd initialisieren
lcd.begin(16, 2); delay(200);  //16 zeichen in 2 zeilen
lcd.setCursor(0,0);
lcd.print(" Homeduino 4.0  ");
#endif  //********************************************************************************​*****

#if defined (tft_display)  //******************************************************************
//+++++++ tft initialisieren
tft.reset();
int identifier = tft.readID();  tft.begin(identifier);
Serial.print(" tft identifier:" ); Serial.println(identifier);  
delay(100);
tft.fillScreen(BLACK); tft.setRotation(tft_rotation);
if (tft_type ==1) //2,4'' display
   {tft_print (1,"  Homeduino",4,YELLOW);
    tft_print (2,"     4.0",4,YELLOW);
    tft_print (5,"www.stall.biz",4,CYAN);
    tft.drawRect(0,0, 319, 240, GREEN);
   }
  if (tft_type ==2)  //3,95'' display
   {tft_print (1,"   Homeduino",5,YELLOW);
    tft_print (2,"      4.0",5,YELLOW);
    tft_print (5," www.stall.biz",5,CYAN);
    tft.drawRect(5,5, 475, 310, GREEN);
   }  
#endif  //********************************************************************************​*****

for(int i=0; i<zeilenzahl; i++)
   {zeile_pointer[i] = EEPROM.read(i);  //anzeige-pointer aus eeprom holen
    if (zeile_pointer[i] >79) {zeile_pointer[i] = 0;}  //wenn eeprom erstes mal benutzt wird
   }

#if defined (w5100)  //************************************************************************
//hier folgt die LAN Initialisierung
char myIpString[24];
if (Ethernet.begin(mac) == 0) // start the Ethernet connection:
   {Serial.println("Failed to configure Ethernet using DHCP"); Ethernet.begin(mac, homeduino);}
    delay(1000);// give the Ethernet shield a second to initialize:
    Serial.println("connecting..."); // if you get a connection, report back via serial:
if (client.connect(ccu, 8181)) {}
   else {Serial.println("connection failed");} // if you didn't get a connection to the server:
client.stop();
IPAddress myIp = Ethernet.localIP();
sprintf(myIpString, "%d.%d.%d.%d", myIp[0], myIp[1], myIp[2], myIp[3]);
I = myIpString;
befehl = "GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"IP"+"').State('"+ I + "')";
set_sysvar();
server.begin();
#endif  //********************************************************************************​*****

#if defined (cc3000)  //**********************************************************************
// hier folgt die CC3000 Initialisierung
ConnectionInfo connection_info;
char myIpString[24];
Serial.println("SparkFun CC3000 - WebClient");
if ( wifi.init() ) {Serial.println("init complete");}
else {Serial.println("problem with init!");}
// Connect using DHCP
if (!wifi.connect(ap_ssid, ap_security, ap_password, timeout))
   {Serial.println("no connection to AP");}
//build IP address
if ( !wifi.getConnectionInfo(connection_info) ) {Serial.println("no connection details");}
   else {sprintf(myIpString, "%d.%d.%d.%d", connection_info.ip_address[0],
   connection_info.ip_address[1],connection_info.ip_address[2], connection_info.ip_address[3]);
         I = myIpString;
        }
befehl = "GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"IP"+"').State('" + I + "')";
set_sysvar();
client.stop();
#endif  //********************************************************************************​*****

#if defined (lcd_display)  //******************************************************************
//bei erfolgreichem einloggen ausgabe ip-adresse
lcd.setCursor(0,1);
lcd.print(myIpString);
delay(3000);
#endif  //********************************************************************************​*****

#if defined (tft_display) //*******************************************************************
//bei erfolgreichem einloggen ausgabe ip-adresse
tft.fillScreen(BLACK);
if (tft_type ==1) //2,4'' display
  {tft.setCursor(8, 230); //fusszeile
   tft.setTextColor(GREEN);  
   tft.setTextSize(1);
   tft.print(Version + "   Homeduino IP: "); tft.print( myIpString);
  }
if (tft_type ==2) //3,95'' display
  {tft.setCursor(1, 300); //fusszeile
   tft.setTextColor(GREEN);  
   tft.setTextSize(2);
   tft.print(Version + " IP: "); tft.print( myIpString);
  }
#endif  //********************************************************************************​*****
for (int i = 0; i < 80; i++) {next_Time[i]=0;} //
//delay(2000);
}
//################################################################################​#############
//################################################################################​#############
void loop()
{complete_loop = 0;
if (millis() > next_full_loop) //mindestens jede Stunde eine komplette Aktualisierung
   {complete_loop = 1; next_full_loop = millis() + delta_time;
    if (next_full_loop < millis()) {complete_loop = 0;} //wichtig wegen Zahlensprung
                                                        //von millis() alle 50 Tage
   }
//********************************************************************************​*************
for (int i = 2; i < 70; i++) //behandlung aller Ports D2 bis D69
{while ((iomodus_D[i] == 0) || (iomodus_D[i] >29 )) {i++;}  // unbenutzte pins überspringen
  datenempfang(); //nach jeder Messung auf Datenempfang schalten
  display_data(); //display ausgeben und abfragen
//********************************************************************************​************
if (iomodus_D[i] == 1) //behandlung digitaleingänge
   {if (millis() > next_Time[i])
      {next_Time[i] = next_Time[i] +1000;  //digitaleingänge nicht häufiger als alle 1000ms abfragen
       pinMode(i, INPUT_PULLUP);
       digitalWrite(i, HIGH);
       value =digitalRead(i);
       for (int m=0; m < zeilenzahl; m++)
         {if (zeile_pointer[m] == i)
            {if (value ==0) {zeile_data[m] = "LOW";} else {zeile_data[m] = "HIGH";}}}
       if ((!value == last_digital_value_D[i]) || complete_loop)
         {I = String(i);
          befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"D"+I+"').State("+value+")";
          set_sysvar();
          last_digital_value_D[i] = value;
         }
      }
   }
//********************************************************************************​*************
if (iomodus_D[i] == 3) //behandlung onewire
   {if (millis() > next_Time[i])
      {next_Time[i] = next_Time[i] +10000;  //onewire nicht häufiger als alle 10s abfragen
       pinMode(i, INPUT_PULLUP);
       digitalWrite(i,HIGH);
       OneWire ds(i);
       #define DS18S20_ID 0x10
       #define DS18B20_ID 0x28
       byte present = 0;   byte data[12];    byte addr[8];
       temp_tur = 1000.0;
       if (!ds.search(addr)) { ds.reset_search(); temp_tur = -1000.0; } //find a device
       if ((OneWire::crc8( addr, 7) != addr[7]) && (temp_tur > -1000.0)) {temp_tur = -1000.0; }
       if ((addr[0] != DS18S20_ID && addr[0] != DS18B20_ID)&& (temp_tur > -1000.0))
         {temp_tur = -1000.0;}
       if (temp_tur > -1000.0)
         {ds.reset();
          ds.select(addr);
          ds.write(0x44, 1); // Start conversion
          //delay(850); // Wait some time...
          time_wait = millis() +850;                       //wahrend der 2s wartezeit, daten empfangen
          while (millis() < time_wait) {datenempfang();display_data;} //und display weiter bedienen
          present = ds.reset();
          ds.select(addr);
          ds.write(0xBE); // Issue Read scratchpad command
          for ( int k = 0; k < 9; k++) { data[k] = ds.read(); } // Receive 9 bytes
          temp_tur = ( (data[1] << 8) + data[0] )*0.0625; // Calculate temperature value 18B20
          //temp_tur = ( (data[1] << 8) + data[0] )*0.5 // Calculate temperature value 18S20
         }
       for (int m=0; m < zeilenzahl; m++)
         {if (zeile_pointer[m] == i) {zeile_data[m] = String(temp_tur,1);}
         }
       if ((temp_tur > (last_value_D[i] + delta_onewire))
                            || (temp_tur < (last_value_D[i] - delta_onewire)) || complete_loop)
         {I = String(i);
          befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"D"+I+"').State("+temp_tur+")";
          set_sysvar();
          last_value_D[i] = temp_tur;
         }
      }  
  }
//********************************************************************************​*************
if (iomodus_D[i] == 4) //behandlung DHT temperatur- und feuchtesensoren
   {if (millis() > next_Time[i])
      {next_Time[i] = next_Time[i] +30000;  //DHT nicht häufiger als alle 30s abfragen
       DHT dht(i, DHT22); //je nach verwendetem sensor "DHT11", "DHT22" (AM2302),"DHT 21" (AM2301)
       dht.begin();
       //delay(2000); // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
       time_wait = millis() +2000;                       //wahrend der 2s wartezeit, daten empfangen
       while (millis() < time_wait) {datenempfang();display_data;} //und display weiter bedienen
       humidity = dht.readHumidity(); // Read temperature as Celsius
       temp_tur = dht.readTemperature();
       if (isnan(humidity) || isnan(temp_tur) ) // Check if any reads failed and
         {//Serial.println("Failed to read from DHT sensor!");
          temp_tur = -1000;
         }
       for (int m=0; m < zeilenzahl; m++)
         {if (zeile_pointer[m] == i) {zeile_data[m] = String(temp_tur,1);}
         }
       if ((temp_tur > (last_value_D[i] + delta_DHT))|| (temp_tur < (last_value_D[i] - delta_DHT))
                                                  || complete_loop)
         {I = String(i);
          befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"D"+I+"').State("+temp_tur+")";
          set_sysvar();
          befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"D"+I+"_1').State("+humidity+")";
          set_sysvar();
          last_value_D[i] = temp_tur;
        }
     }
   }
//********************************************************************************​************
if (iomodus_D[i] == 5) //behandlung ultraschallsensoren
   {if (millis() > next_Time[i])
      {next_Time[i] = next_Time[i] +2000;  //ultraschall nicht häufiger als alle 2s abfragen
//achtung: zu beachten
//bei verwendung der US-Sensoren beim IO-Shield-Plus sind die 150-Ohm-Schutzwiderstände
//zu überbrücken (Jumper setzen!), entsprechend beim IO-Shield20 der Jumper 4-5 zu setzen!!
       NewPing sonar(i, i, 200); // NewPing setup of pin and maximum distance.
       unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS).
       int cm = uS / US_ROUNDTRIP_CM;
       for (int m=0; m < zeilenzahl; m++)
         {if (zeile_pointer[m] == i) {zeile_data[m] = String(cm);}}
          if ((cm > (last_value_D[i] + delta_us)) || (cm < (last_value_D[i] - delta_us)) || complete_loop)
            {I = String(i);
             befehl = "GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"D"+I+"').State("+cm+")";
             set_sysvar();
             last_value_D[i] = cm;
            }
      }
   }
//********************************************************************************​*************
if (iomodus_D[i] == 10) //behandlung analogeingänge
   {if (millis() > next_Time[i])
      {next_Time[i] = next_Time[i] +1000;  //analogeingänge nicht häufiger als alle 1000ms abfragen
       analogwert =analogRead(i);
       for (int m=0; m < zeilenzahl; m++)
         {if (zeile_pointer[m] == i) {zeile_data[m] = String(analogwert);}}
       if ((analogwert > (last_value_D[i] + delta_analog))
                || (analogwert < (last_value_D[i] - delta_analog)) || complete_loop)
         {I = String(i);
          befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"D"+I+"').State("+analogwert+")";
          set_sysvar();
          last_value_D[i] = analogwert;
         }
      }
   }
//********************************************************************************​*************
if (iomodus_D[i] == 11) //behandlung NTC
   {if (millis() > next_Time[i])
      {next_Time[i] = next_Time[i] +10000;  //NTC-eingänge nicht häufiger als alle 10s abfragen
       Rt = Rv/((1024.0/analogRead(i))- 1.0);
       tempNTC = (B_wert * Tn / ( B_wert + (Tn * log(Rt/Rn)))) -Tn +25.0 ;
       for (int m=0; m < zeilenzahl; m++)
         {if (zeile_pointer[m] == i) {zeile_data[m] = String(tempNTC,1);}}
          if ((tempNTC > (last_value_D[i] + delta_ntc)) || (tempNTC < (last_value_D[i] - delta_ntc))
                                                   || complete_loop)
            {I = String(i);
             befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"D"+I+"').State("+tempNTC+")";
             set_sysvar();
             last_value_D[i] = tempNTC;
            }
      }
   }    
//********************************************************************************​*************
if (iomodus_D[i] == 6) //behandlung impulszahler D2,D3,D21,D20,D19,D18
   {byte offset =23;
    if (i ==2) {offset = 4;} if (i ==3) {offset = 6;}
    zaehlwert = pulsecounter[offset - i ] / pulsedivider[offset - i ];
    for (int m=0; m < zeilenzahl; m++)
      {if (zeile_pointer[m] == i) {zeile_data[m] = String(zaehlwert);}}
       if ((pulsedivider[offset -i] > 0) && ((zaehlwert > (last_zaehlwert[offset - i]+ delta_counter)
                           || complete_loop)))
         {I = String(offset -i);
          befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"imp"+I+"').State("+zaehlwert+")";
          set_sysvar();
          last_zaehlwert[offset - i] = zaehlwert;
         }
   }
//********************************************************************************​*************
//behandlung I2C sensoren an pin 20(sda) und pin 21 (scl)
if ((iomodus_D[i] == 8)&&(i == 20))
   {i++;  // da I2C Bus 2 eingaenge belegt
  
//behandlung Luxmeter BH1750 an SCL pin21 und SDA pin 20 ***********************************
// for normal sensor resolution (1 lx resolution, 0-65535 lx, 120ms, no PowerDown)
//use: sensor.begin(RESOLUTION_NORMAL, false);
    if (iomodus_lux ==1)
      {if (millis() > next_Time[72])
         {next_Time[72] = next_Time[72] +5000;  //luxmeter nicht haeufiger als alle 5s abfragen
          if(!sensor.begin()) { Serial.println("Sensor not present"); }
          lux = sensor.readLightLevel(); //delay(1000);
          Lux = (int)lux;
          //Serial.print("Helligkeit/lux: "); Serial.print(lux); Serial.println();
          lux_string = "      " + String(Lux);
          int laenge = lux_string.length();
          lux_string = lux_string.substring(laenge -6,laenge);
          for (int m=0; m < zeilenzahl; m++)
            {if (zeile_pointer[m] == 72) {zeile_data[m] = lux_string;}}
             if (((Lux > (last_value_D[72] + delta_lux)) || (Lux < (last_value_D[72] - delta_lux))
                                                || complete_loop))
               {befehl="GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable+"lux"+"').State("+Lux+")";
                set_sysvar();
                last_value_D[72] = Lux;
               }
         }
       }
//***********************************************************************//behandlung SHT21 an SCL pin21 und SDA pin 20
//behandlung Temperatur- und Feuchtesensor an SCL pin21 und SDA pin 20
    if (iomodus_sht ==1)
      {if (millis() > next_Time[70])
         {next_Time[70] = next_Time[70] +10000;  //SHT nicht häufiger als alle 10s abfragen
          if (sht.begin()) {status = sht.GetTemperature();}
          if (status) {delay(status); status = sht.GetTemperature(T);}
          if (status) {delay(status); status = sht.GetHumidity(H);}
          sht_string = "     " + String(H);
          laenge = sht_string.length();
          sht_string = sht_string.substring(laenge -7,laenge -1);
          shtT_string = "      " + String(T);
          laenge = shtT_string.length();
          shtT_string = shtT_string.substring(laenge -7,laenge -1);
          for (int m=0; m < zeilenzahl; m++) {if (zeile_pointer[m] == 70) {zeile_data[m] = sht_string;}}
          if ((H > (last_sht_value + delta_sht)) || (H < (last_sht_value - delta_sht)) || complete_loop)
            {befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"sht"+"').State("+H+")";
             set_sysvar();
             last_sht_value = H;
             last_value_D[70] = H;
            }
          for (int m=0; m < zeilenzahl; m++) {if (zeile_pointer[m] == 71) {zeile_data[m] = shtT_string;}}  
          if ((T > (last_shtT_value + delta_shtT)) || (H < (last_shtT_value - delta_shtT)) || complete_loop)
            {befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"shtT"+"').State("+T+")";
             set_sysvar();
             last_shtT_value = T;
             last_value_D[71] = T;
            }
         }
      }
  }
//********************************************************************************​*************
if (iomodus_D[3] == 7) //behandlung 433Mhz-rx
   {if (mySwitch.available())
      {int value = mySwitch.getReceivedValue();
       if (value == 0) {client.print("Unknown encoding");}
          else {Serial.print("Pin D3 received : ");
                Serial.print (mySwitch.getReceivedValue() );
                Serial.print (" / ");
                Serial.print( mySwitch.getReceivedBitlength() );
                Serial.print("bit Protocol: ");
                Serial.println( mySwitch.getReceivedProtocol() + " \n\r" );
               }
      mySwitch.resetAvailable();
     }
   }
  //********************************************************************************​***********
if ((iomodus_D[i] == 12) && (i==22))  //behandlung rfid3 tueroeffner an D22 des Mega
   {pinMode(i,OUTPUT);
    if (millis()< time_rfid3)         //D22-als normal-Ausgang für tueröffner schalten
      {Value = " AUF";
       if (oeffner_polarity) {digitalWrite(i, HIGH);} else {digitalWrite(i,LOW);}
       }
         else {Value = "  ZU"; if (!oeffner_polarity)
                               {digitalWrite(i, HIGH);} else {digitalWrite(i,LOW);}}
       for (int m=0; m < zeilenzahl; m++)
         {if (zeile_pointer[m] == i) {zeile_data[m] = Value;}}
    }
  if ((iomodus_D[i] == 12) && (i==23))  //behandlung rfid2 tueroeffner  an D23 des Mega
    {pinMode(i,OUTPUT);
     if (millis()< time_rfid2)         //D23-als normal-Ausgang für tueröffner schalten
       {Value = " AUF"; if (oeffner_polarity)
                          {digitalWrite(i, HIGH);}
                          else {digitalWrite(i,LOW);}}
       else {Value = "  ZU"; if (!oeffner_polarity) {digitalWrite(i, HIGH);}
                                                    else {digitalWrite(i,LOW);}}
     for (int m=0; m < zeilenzahl; m++)
       {if (zeile_pointer[m] == i) {zeile_data[m] = Value;}
       }
    }
//********************************************************************************​************
  if (iomodus_D[i] == 12) //behandlung rfid-modul RDM6300
    {int m = 0; fob_zahl=0;  fob_hex ="";
     if (i == 15){while((Serial3.available()>0)&&(m <11 ))  //behandlung rfid3
                       {fob_da=1;  m++;  zeichen = Serial3.read();
                        if (m>4)  //die ersten 4 zeichen ignorieren
                          {fob_hex += zeichen; fob_zahl = hexToDec(fob_hex);}
                        if (m > 10) //Datenübertragung fertig, dann buffer leeren
                          {while(Serial3.available()>0) {zeichen = Serial3.read();}}
             }
         }    
     if (i == 17){while((Serial2.available()>0)&&(m <11 ))//behandlung rfid2
                      {fob_da=1;  m++;  zeichen = Serial2.read();
                       if (m>4)  //die ersten 4 zeichen ignorieren
                         {fob_hex += zeichen; fob_zahl = hexToDec(fob_hex);}
                       if (m > 10) //Datenübertragung fertig, dann buffer leeren
                         {while(Serial2.available()>0) {zeichen = Serial2.read();}}
            }
           }
     if (fob_da)
       {fob_dec = "";
        sprintf(buffer,"%lu", fob_zahl); //zahl umwandeln in string
        for(int k = 0; k<7; k++) {fob_dec += buffer[k];}
        Name = "";  //gueltigen namen und oeffner aus tabelle ermitteln  
        for (int k = 0; k < fob_anzahl; k++) {if (fob_dec == fob[3*k])
                                                {Name += fob[(3*k)+1];
                                                 oeffner= fob[(3*k)+2];
                                                 break;
                                                }
                                              }
        if ((Name != "") && ((oeffner =="1") ||(oeffner =="3")))
          {time_rfid3 = millis() + unlock_time1;}
        if ((Name != "") && ((oeffner =="2") ||(oeffner =="3")))  
          {time_rfid2 = millis() + unlock_time2;}
        if (Name == "") {Name = fob_dec;}
        lcd_rfid_message = Name + "          "; //lcd mmeldung modifizieren für rfid
        lcd_rfid_message = lcd_rfid_message.substring(0,9);
        
        for (int n=0; n < zeilenzahl; n++)
          {if (zeile_pointer[n] == i)
             {display_message[i]= lcd_rfid_message; zeile_data[n] = fob_dec;}
          }
          
     //Serial.println(Name + " " + fob_dec);
        I = String(i);
        befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"D"+I+"').State('"+Name+"')";
        set_sysvar();
        fob_da =0;
       }
     delay(500);  
    }
//**************************   ende loop  *****************************************************
}
}
//################################################################################​#############
//################################################################################​#############
//#############################  Unterprogramme   #############################################

void datenempfang() //Unterprogramm datenempfang: daten von ccu an homeduino senden
{command = "";

#if defined (w5100)  //************************************************************************
EthernetClient client = server.available();   //mit W5100
#endif  //********************************************************************************​*****

#if defined (cc3000)  //***********************************************************************
SFE_CC3000_Client client = SFE_CC3000_Client(wifi);   //mit CC3000
#endif  //********************************************************************************​*****

if (client) // an http request ends with a blank line
   {boolean currentLineIsBlank = true;
    while (client.connected())
      {if (client.available())
         {char c = client.read();
          if (reading && c == ' ') reading =false;
          if (c == '?') reading = true; // beginn der Befehlssequenz
          if (reading)
            {if (command.length() < 100) //read char by char HTTP request
               {command = command + c; } //store characters to string
            }
          if (c == '\n' && currentLineIsBlank) break;
          if (c == '\n') {currentLineIsBlank = true;}
            else if (c != '\r') { currentLineIsBlank = false;}
         }
       }
     client.println(command);
     delay(1);
     client.stop();
//********************************************************************************​*************
    if (command.length() > 2) //behandlung Datenempfang von ccu: port auf 0/1 setzen
      {Serial.println(command); //empfangenen befehl ausgeben
       client.print(command); //befehl dann dekodieren
       int colonPosition = command.indexOf(':');
       sub_command = command.substring(2,colonPosition); //portpin erkennen
       Serial.print("D" + sub_command + " :");
       port_pin = sub_command.toInt();
       command = command.substring((colonPosition+1)); //Rest-command bilden
       if (((iomodus_D[port_pin] == 2)||(iomodus_D[port_pin] == 12)) && (command == "0"))
         {for (int m=0; m < zeilenzahl; m++)
            {if (zeile_pointer[m] == port_pin) {zeile_data[m] = " LOW";}
            }
          pinMode(port_pin, OUTPUT); digitalWrite(port_pin, LOW); Serial.println(command);
         }
       if ((iomodus_D[port_pin] == 2) && (command == "1"))
         {for (int m=0; m < zeilenzahl; m++)
            {if (zeile_pointer[m] == port_pin) {zeile_data[m] = " HIGH";}
            }
          pinMode(port_pin, OUTPUT); digitalWrite(port_pin, HIGH); Serial.println(command);}
          if ((iomodus_D[port_pin] == 7) && (port_pin ==4))
            {rf_send(command); Serial.println(command);}
          if ((iomodus_D[port_pin] == 5) && (port_pin ==9))
            {ir_send(command); Serial.println(command);}
      }
  }
}
//********************************************************************************​*************
void set_sysvar() // subroutine HTTP request absetzen:
{//while (millis() < next_tx) {} //warten bis time > next_tx oder timeout
next_tx = millis() +delta_tx;
if (client.connect(ccu, 8181))
   {Serial.println(befehl);
    client.println(befehl);
    client.println();
    client.stop();
   } else {Serial.println("connection failed");}
}
//********************************************************************************​*************
void rf_send(String rf_command) // subroutine rf telegramm senden
{
}
//********************************************************************************​*************
void ir_send(String ir_command) // subroutine ir telegramm senden
{
}
//********************************************************************************​*************
//hier sind die interrupt-service-routinen fuer die impulszaehler  //**************************
void ISR_0() //Interrupt an D2
{pulsecounter[0]++;}
void ISR_1() //Interrupt an D3
{pulsecounter[1]++;}
void ISR_2() //Interrupt an D21
{pulsecounter[2]++;}
void ISR_3() //Interrupt an D20
{pulsecounter[3]++;}
void ISR_4() //Interrupt an D19
{pulsecounter[4]++;}
void ISR_5() //Interrupt an D18
{pulsecounter[5]++;}
//********************************************************************************​*************
//Unterprogramm:  Converting from Hex (unsigned long) to Decimal: *****************************
//Quelle https://github.com/benrugg/Arduino-Hex-Decimal-Conversion/blob/master/hex_dec.ino
unsigned long hexToDec(String hexString)
{unsigned long decValue = 0;
int nextInt;
for (int k = 0; k < hexString.length(); k++)
   {nextInt = int(hexString.charAt(k));
    if (nextInt >= 48 && nextInt <= 57) nextInt = map(nextInt, 48, 57, 0, 9);
    if (nextInt >= 65 && nextInt <= 70) nextInt = map(nextInt, 65, 70, 10, 15);
    if (nextInt >= 97 && nextInt <= 102) nextInt = map(nextInt, 97, 102, 10, 15);
    nextInt = constrain(nextInt, 0, 15);
    decValue = (decValue * 16) + nextInt;
  }
return decValue;
}

//********************************************************************************​*************
void display_data() //gibt daten auf dem lcd oder tft display aus

//********************************************************************************​*************
#if defined (lcd_display)  //behandlung lcd-display: erkennung des tasters und lcd-anzeige
{x = analogRead (0);  //abfrage A0
if (x < (x_alt -100))  {tastererkennung();}
x_alt = x;
for (int m = 0; m < zeilenzahl; m++)
   {while (zeile_data[m].length() < 5) {zeile_data[m] = " " + zeile_data[m];}
    if (display_message[zeile_pointer[m]] == "0") {zeile_data[m] = "                ";}
    display_zeile[m] =  display_message[zeile_pointer[m]] + zeile_data[m];
  
    if (display_zeile[m] != display_zeile_alt[m])  //datenausgabe auf display nur wenn aenderung
      {lcd.setCursor(0,m); lcd.print (display_zeile[m]); display_zeile_alt[m] = display_zeile[m];}
   }
}
//********************************************************************************​*************
void tastererkennung()
{if (x < 60)
   {taster == "right";
    zeile_pointer[0]--;  if (zeile_pointer[0] ==1) {zeile_pointer[0] = 79;}
    while((iomodus_D[zeile_pointer[0]] ==0) || (iomodus_D[zeile_pointer[0]] >19))
         {zeile_pointer[0]--; if (zeile_pointer[0] ==1) {zeile_pointer[0] =79;} }
    EEPROM.write(0,zeile_pointer[0]);//delay(4);
   }
   else if (x < 200)
          {taster == "up";
           zeile_pointer[0]++;  if (zeile_pointer[0] ==80) {zeile_pointer[0] = 2;}
           while((iomodus_D[zeile_pointer[0]] ==0) || (iomodus_D[zeile_pointer[0]] >19))
               {zeile_pointer[0]++; if (zeile_pointer[0] ==80) {zeile_pointer[0] = 2;} }
           EEPROM.write(0,zeile_pointer[0]);//delay(4);
          }
          else if (x < 400)
                   {taster == "down";
                    zeile_pointer[1]++; if (zeile_pointer[1] ==80) {zeile_pointer[1] = 2;}
                    while((iomodus_D[zeile_pointer[1]] ==0) || (iomodus_D[zeile_pointer[1]] >19))
                         {zeile_pointer[1]++; if (zeile_pointer[1] ==80) {zeile_pointer[1] = 2;} }
                    EEPROM.write(1,zeile_pointer[1]);//delay(4);    
                   }
                  else if (x < 600)
                         {taster == "left";
                          zeile_pointer[1]--;
                          if (zeile_pointer[1] ==1) {zeile_pointer[1] = 79;}
                          while((iomodus_D[zeile_pointer[1]] ==0) || (iomodus_D[zeile_pointer[1]] >19))
                               {zeile_pointer[1]--; if (zeile_pointer[1] ==1) {zeile_pointer[1] =79;} }
                          EEPROM.write(1,zeile_pointer[1]);//delay(4);
                         }
                         else if (x < 800)
                                {taster = "select";}
                                else {taster ="";}
}
#endif  //********************************************************************************​*****

//********************************************************************************​*************
#if defined (tft_display)  //behandlung tft toucheingabe und  display 2.4''
{if (millis() > next_touch_time)  //touch-display abfragen
   {TSPoint p = ts.getPoint();// a point object holds x y and z coordinates
    px = p.x; py = p.y; pz =p.z;  
    pinMode(XM, OUTPUT);   pinMode(YP, OUTPUT);
    if (pz > MINPRESSURE && pz < MAXPRESSURE )
      {Serial.print("px : ");Serial.print( px); Serial.print("  py : " ); Serial.print(py);
       Serial.print("  pz : " ); Serial.print(pz);
       if (abs(px_B - px_A) > 100) {p_x = (1000 *(px- px_A))/(px_B -px_A); p_y = (1000 *(py - py_A))/(py_C -py_A);}
         else {p_x = (1000 *(py -py_A))/(py_B - py_A); p_y = (1000 *(px - px_A)) /(px_C - px_A);}
       Serial.print("  p_x : ");Serial.print( p_x); Serial.print("  p_y : " ); Serial.print(p_y);
       if (p_y < 154) {touch_y = 0;}   //p_y = 1000 entspricht 6,5 Zeilen
         else {if (p_y < 308) {touch_y = 1;}
                 else {if (p_y < 462) {touch_y = 2;}
                         else {if (p_y < 616) {touch_y = 3;}
                                 else {if (p_y < 770) {touch_y = 4;}
                                         else {touch_y = 5;}}}}}
       Serial.print("     touch_y "); Serial.print(touch_y); Serial.println();
       if (p_x < 500) {zeile_pointer_minus();}  //Serial.println(zeile_pointer[touch_y]);}
       if (p_x > 500) {zeile_pointer_plus(); }  //Serial.println(zeile_pointer[touch_y]);}
       touch_alt = touch;
      }
    for (int m = 0; m < zeilenzahl; m++)  //datenausgabe auf tft-display
      {while (zeile_data[m].length() < 7) {zeile_data[m] = " " + zeile_data[m];}
       display_zeile[m] =  display_message[zeile_pointer[m]] + zeile_data[m];
       if (display_zeile[m] != display_zeile_alt[m]) //displayausgabe nur wenn aenderung
         {tft_print (m,display_zeile[m],schriftgroesse,WHITE); display_zeile_alt[m] = display_zeile[m];}
      }
   }
}
//********************************************************************************​*************
//mit diesem Unterprogramm wird auf dem tft display ein zeilen-display 6 x 16  emuliert
void tft_print (int line, String textline, int font_size, long int color)
{if (tft_type ==1)
   {tft.fillRect(0,38*line, 319, 38, BLACK); //x0,y0, width,heights  //zeile loeschen
    tft.setCursor(0, 38*line+6);              //und dann erst schreiben
   }
if (tft_type ==2)
   {tft.fillRect(0,50*line, 479, 50, BLACK); //x0,y0, width,heights  //zeile loeschen
    tft.setCursor(5, 50*line+6);              //und dann erst schreiben
   }  
tft.setTextColor(color);  
tft.setTextSize(font_size);
tft.print(textline);
}
//mit diesen Unterprogrammen wird der zeile_pointer im eeprom abgelegt
void zeile_pointer_plus()
{next_touch_time = millis() + 200;
  zeile_pointer[touch_y]++;  if (zeile_pointer[touch_y] >79) {zeile_pointer[touch_y] = 2;}
while((iomodus_D[zeile_pointer[touch_y]] ==0) || (iomodus_D[zeile_pointer[touch_y]] >19))
  {zeile_pointer[touch_y]++; if (zeile_pointer[touch_y] >79) {zeile_pointer[touch_y] = 2;} }
EEPROM.write(touch_y,zeile_pointer[touch_y]);//delay(4);
}
void zeile_pointer_minus()
{next_touch_time = millis() + 200;
  zeile_pointer[touch_y]--;  if (zeile_pointer[touch_y] <2) {zeile_pointer[touch_y] = 79;}
while((iomodus_D[zeile_pointer[touch_y]] ==0) || (iomodus_D[zeile_pointer[touch_y]] >19))
   {zeile_pointer[touch_y]--; if (zeile_pointer[touch_y] <2) {zeile_pointer[touch_y] =79;}  }
EEPROM.write(touch_y,zeile_pointer[touch_y]);//delay(4);
}      
#endif  //********************************************************************************​*****

Die IDE wirft mir folgende Fehler aus:
Code:
Arduino: 1.6.5 (Windows 8.1), Platine: "Arduino Mega or Mega 2560, ATmega2560 (Mega 2560)"

Verwende die Bibliothek SPI im Ordner: C:\arduino-1.6.5-r2\hardware\arduino\avr\libraries\SPI

Verwende die Bibliothek Wire im Ordner: C:\arduino-1.6.5-r2\hardware\arduino\avr\libraries\Wire

Verwende die Bibliothek OneWire im Ordner: C:\arduino-1.6.5-r2\libraries\OneWire (legacy)

Verwende die Bibliothek NewPing im Ordner: C:\arduino-1.6.5-r2\libraries\NewPing (legacy)

Verwende die Bibliothek DHT sensor library im Ordner: C:\arduino-1.6.5-r2\libraries\DHT-sensor

Verwende die Bibliothek AS_BH1750 im Ordner: C:\arduino-1.6.5-r2\libraries\AS_BH1750 (legacy)

Verwende die Bibliothek SFE_BMP180 im Ordner: C:\arduino-1.6.5-r2\libraries\SFE_BMP180 (legacy)

Verwende die Bibliothek RCSwitch im Ordner: C:\arduino-1.6.5-r2\libraries\RCSwitch (legacy)

Verwende die Bibliothek EEPROM im Ordner: C:\arduino-1.6.5-r2\hardware\arduino\avr\libraries\EEPROM

Verwende die Bibliothek SHT2x im Ordner: C:\arduino-1.6.5-r2\Sketchbook\libraries\SHT2x (legacy)

Verwende die Bibliothek Ethernet im Ordner: C:\arduino-1.6.5-r2\libraries\Ethernet

Verwende die Bibliothek Adafruit_GFX im Ordner: C:\arduino-1.6.5-r2\libraries\Adafruit_GFX (legacy)

Verwende die Bibliothek Adafruit_TFTLCD im Ordner: C:\arduino-1.6.5-r2\libraries\Adafruit_TFTLCD (legacy)

Verwende die Bibliothek Touch-Screen im Ordner: C:\arduino-1.6.5-r2\libraries\Touch-Screen (legacy)

Verwende die Bibliothek LiquidCrystal im Ordner: C:\arduino-1.6.5-r2\libraries\LiquidCrystal



C:\arduino-1.6.5-r2\hardware\tools\avr/bin/avr-g++ -c -g -Os -w -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -MMD -mmcu=atmega2560 -DF_CPU=16000000L -DARDUINO=10605 -DARDUINO_AVR_MEGA2560 -DARDUINO_ARCH_AVR -IC:\arduino-1.6.5-r2\hardware\arduino\avr\cores\arduino -IC:\arduino-1.6.5-r2\hardware\arduino\avr\variants\mega -IC:\arduino-1.6.5-r2\hardware\arduino\avr\libraries\SPI -IC:\arduino-1.6.5-r2\hardware\arduino\avr\libraries\Wire -IC:\arduino-1.6.5-r2\libraries\OneWire -IC:\arduino-1.6.5-r2\libraries\NewPing -IC:\arduino-1.6.5-r2\libraries\DHT-sensor -IC:\arduino-1.6.5-r2\libraries\AS_BH1750 -IC:\arduino-1.6.5-r2\libraries\SFE_BMP180 -IC:\arduino-1.6.5-r2\libraries\RCSwitch -IC:\arduino-1.6.5-r2\hardware\arduino\avr\libraries\EEPROM -IC:\arduino-1.6.5-r2\Sketchbook\libraries\SHT2x -IC:\arduino-1.6.5-r2\libraries\Ethernet\src -IC:\arduino-1.6.5-r2\libraries\Adafruit_GFX -IC:\arduino-1.6.5-r2\libraries\Adafruit_TFTLCD -IC:\arduino-1.6.5-r2\libraries\Touch-Screen -IC:\arduino-1.6.5-r2\libraries\LiquidCrystal\src C:\Users\prinz\AppData\Local\Temp\build7315462445360051511.tmp\hduino412_LAN.cpp​ -o C:\Users\prinz\AppData\Local\Temp\build7315462445360051511.tmp\hduino412_LAN.cpp​.o

hduino412_LAN.ino:335:1: error: 'SHT2x' does not name a type
hduino412_LAN.ino: In function 'void loop()':
hduino412_LAN.ino:712:15: error: 'sht' was not declared in this scope
hduino412_LAN.ino:713:48: error: 'sht' was not declared in this scope
hduino412_LAN.ino:714:48: error: 'sht' was not declared in this scope
'SHT2x' does not name a type

Ich hab auch mal den OriginalSketch mit angehängt!
Kann mir da bitte jemand helfen???
Wäre echt klasse von euch!

Johnny


Angehängte Datei(en)
.zip  hduino412_LAN.zip (Größe: 13,11 KB / Downloads: 8)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
06.04.2016, 10:40
Beitrag #2
RE: SHT21 in Sketch intigrieren
Ich befürchte, du solltest es besser vom Ersteller machen lassen.
Sich in den Sketch einzuarbeiten, ist schon sehr aufwändig.

Ich habe es versucht. Wink
Du musst die von dir gemachten Änderungen auch mal im Sketch deutlich kennzeichnen, damit wir die finden.

Die Fehlermeldung am Ende sagt, du hast einige Variablen nicht deklariert.

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
06.04.2016, 11:47
Beitrag #3
RE: SHT21 in Sketch intigrieren
Erstmal danke für Deine Antwort :-)
Also ich zerlege jetzt mal den Sketch wo ich Ihn verändert habe!
Im Original-sketch hatte Eugen ne Funktion eingebaut einen Barometer BMP180 abzufragen.
Die Funktion hab auf den SHT abgeändert.

Ich hab das wie folgt geändert
Original:
//hier werden Sensoren am I2C-Eingang aktiviert
const byte iomodus_baro = 1; //'0' =nc; '1' =BMP180, <<user IO-Shield-Plus<<
const byte iomodus_lux = 1; //'0' =nc; '1' =BH1750, <<user IO-Shield-Plus<<

Geänderte Version:
//hier werden Sensoren am I2C-Eingang aktiviert
const byte iomodus_lux = 0; //'0' =nc; '1' =BMP180,                   <<user IO-Shield-Plus<<
const byte iomodus_sht =  1; //'0' =nc; '1' =SHT21,                   <<user IO-Shield-Plus<<
//################################################################################​​#############


Original:
#include <SPI.h>
#include <Wire.h>
#include <OneWire.h> //für Temperatursensoren DS18B20
//http://www.hacktronics.com/code/OneWire.zip
#include <NewPing.h> //für Ultraschallsensoren SR04
//https://arduino-new-ping.googlecode.com/files/NewPing_v1.5.zip
#include "DHT.h" //für Temperatursensoren SHT22
//https://github.com/adafruit/DHT-sensor-library/archive/master.zip
#include <AS_BH1750.h> //für I2C-Luxmeter
//https://github.com/hexenmeister/AS_BH1750/archive/master.zip
#include <SFE_BMP180.h>//für I2C-Barometer
//https://github.com/sparkfun/BMP180_Breakout/archive/master.zip
#include <RCSwitch.h> // läuft noch nicht!
#include <EEPROM.h>


//#include <IRremote.h>// läuft noch nicht!


Geänderte Version:

#include <SPI.h>
#include <Wire.h>
#include <OneWire.h> //für Temperatursensoren DS18B20
//http://www.hacktronics.com/code/OneWire.zip
#include <NewPing.h> //für Ultraschallsensoren SR04
//https://arduino-new-ping.googlecode.com/files/NewPing_v1.5.zip
#include "DHT.h" //für Temperatursensoren SHT22
//https://github.com/adafruit/DHT-sensor-library/archive/master.zip
#include <AS_BH1750.h> //für I2C-Luxmeter
//https://github.com/hexenmeister/AS_BH1750/archive/master.zip
#include <SFE_BMP180.h>//für I2C-Barometer
//https://github.com/sparkfun/BMP180_Breakout/archive/master.zip
#include <RCSwitch.h> // läuft noch nicht!
#include <EEPROM.h>
#include <SHT2x.h>

//#include <IRremote.h>// läuft noch nicht!


Original:
//********************************************************************************​*************
AS_BH1750 sensor; //Initialize BH1750 Luxmeter library
float lux;
long Lux;
int laenge;
const float ALTITUDE = 299.0; // eigene seehoehe in metern <<user IO-Shield-Plus<<

SFE_BMP180 pressure;
char status;
double T,P,p0;
boolean reading = false;
String command = String(200);
String baro_string,baroT_string, lux_string;

//********************************************************************************​*************
boolean last_digital_value_D[80];
float last_value_D[80],last_IR_value,last_RF_value;
unsigned long next_Time[80];
double last_baro_value,last_baroT_value;
boolean complete_loop =1; // wenn 1, dann einmal komplett durchlaufen
String befehl,sub_command = String(20),parameter = String(20),header = String(20);
int param,port_pin;
boolean port_data;
boolean value;
String I;
int analogwert;

//********************************************************************************​*************

Geänderte Version:
//********************************************************************************​​************* 

AS_BH1750 sensor; //Initialize BH1750 Luxmeter library
float lux;
long Lux;
int laenge;
const float ALTITUDE = 299.0; // eigene seehoehe in metern              <<user IO-Shield-Plus<<
SHT2x.h sht;
SFE_BMP180 pressure;
char status;
float T,H,p0;
boolean reading = false;
String command = String(200);
String sht_string,shtT_string, lux_string;
//********************************************************************************​​************* 

boolean last_digital_value_D[80];
float last_value_D[80],last_IR_value,last_RF_value;
unsigned long next_Time[80];  
float last_sht_value,last_shtT_value;
boolean complete_loop =1; // wenn 1, dann einmal komplett durchlaufen
String befehl,sub_command = String(20),parameter = String(20),header = String(20);
int param,port_pin;
boolean port_data;
boolean value;
String I;
int analogwert;
//********************************************************************************​​************* 
Original:
const float delta_onewire = 0.2; //Deltas für Sendeauslösung
const float delta_DHT = 0.2; //in °C
const float delta_us = 3.0; // in cm
const float delta_analog = 2.0; // in inkrement
const float delta_ntc = 0.5; //in °C
const float delta_lux = 15; //in lux
const float delta_counter = 5; //in counter inkrement
const double delta_baro = 0.5; //in mB
const double delta_baroT = 0.5; //in °C

Geänderte Version:
const float delta_onewire = 0.2; //Deltas für Sendeauslösung 
const float delta_DHT = 0.2; //in °C 
const float delta_us = 3.0; // in cm
const float delta_analog = 2.0; // in inkrement
const float delta_ntc = 0.5; //in °C
const float delta_lux = 15; //in lux
const float delta_counter = 5; //in counter inkrement
const float delta_sht = 0.2; //in %
const float delta_shtT = 0.2; //in °C

Original:
//behandlung I2C sensoren an pin 20(sda) und pin 21 (scl)
if ((iomodus_D[i] == 8)&&(i == 20))
{i++; // da I2C Bus 2 eingaenge belegt


//behandlung Luxmeter BH1750 an SCL pin21 und SDA pin 20 ***********************************
// for normal sensor resolution (1 lx resolution, 0-65535 lx, 120ms, no PowerDown)
//use: sensor.begin(RESOLUTION_NORMAL, false);
if (iomodus_lux ==1)
{if (millis() > next_Time[72])
{next_Time[72] = next_Time[72] +5000; //luxmeter nicht häufiger als alle 5s abfragen
if(!sensor.begin()) { Serial.println("Sensor not present"); }
lux = sensor.readLightLevel(); //delay(1000);
Lux = (int)lux;
//Serial.print("Helligkeit/lux: "); Serial.print(lux); Serial.println();
lux_string = " " + String(Lux);
int laenge = lux_string.length();
lux_string = lux_string.substring(laenge -6,laenge);
for (int m=0; m < zeilenzahl; m++)
{if (zeile_pointer[m] == 72) {zeile_data[m] = lux_string;}}
if (((Lux > (last_value_D[72] + delta_lux)) || (Lux < (last_value_D[72] - delta_lux))

|| complete_loop))
{befehl="GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable+"lux"+"').State("+Lux+")";

set_sysvar();
last_value_D[72] = Lux;




}
}
}
//behandlung barometer BMP180 an SCL pin21 und SDA pin 20
if (iomodus_baro ==1)
{if (millis() > next_Time[70])
{next_Time[70] = next_Time[70] +30000; //barometer nicht häufiger als alle 30s abfragen
if (pressure.begin()) {status = pressure.startTemperature();}
if (status) {delay(status); status = pressure.getTemperature(T);} //messung T
if (status) {status = pressure.startPressure(3);} // //messung P mit resolution 0 bis 3
if (status) {delay(status); status = pressure.getPressure(P,T);}

if (status) {p0 = pressure.sealevel(P,ALTITUDE);} // umrechnung auf N.N.
//Serial.print("Hoehe/m: "); Serial.print(ALTITUDE); Serial.print(" Temperatur/C: ");
//Serial.print(T); Serial.print(" Normaldruck /mb: "); Serial.println(p0);
baro_string = " " + String(p0);
laenge = baro_string.length();
baro_string = baro_string.substring(laenge -7,laenge -1);

baroT_string = " " + String(T);
laenge = baroT_string.length();
baroT_string = baroT_string.substring(laenge -7,laenge -1);
for (int m=0; m < zeilenzahl; m++) {if (zeile_pointer[m] == 70) {zeile_data[m] = baro_string;}}
if ((p0 > (last_baro_value + delta_baro)) || (p0 < (last_baro_value - delta_baro))
|| complete_loop)
{befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"baro"+"').State("+p0+")";
set_sysvar();

last_baro_value = p0;
last_value_D[70] = p0;

}
for (int m=0; m < zeilenzahl; m++) {if (zeile_pointer[m] == 71) {zeile_data[m] = baroT_string;}}
if ((T > (last_baroT_value + delta_baroT)) || (p0 < (last_baroT_value - delta_baroT))
|| complete_loop)
{befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"baroT"+"').State("+T+")";
set_sysvar();

last_baroT_value = T;
last_value_D[71] = T;





}
}
}
}
//********************************************************************************​*************


Geänderte Version:

//behandlung I2C sensoren an pin 20(sda) und pin 21 (scl)
if ((iomodus_D[i] == 8)&&(i == 20))
   {i++;  // da I2C Bus 2 eingaenge belegt
  

//behandlung Luxmeter BH1750 an SCL pin21 und SDA pin 20 ***********************************
// for normal sensor resolution (1 lx resolution, 0-65535 lx, 120ms, no PowerDown) 
//use: sensor.begin(RESOLUTION_NORMAL, false); 
    if (iomodus_lux ==1)
      {if (millis() > next_Time[72])
         {next_Time[72] = next_Time[72] +5000;  //luxmeter nicht haeufiger als alle 5s abfragen 
          if(!sensor.begin()) { Serial.println("Sensor not present"); }
          lux = sensor.readLightLevel(); //delay(1000);
          Lux = (int)lux;
          //Serial.print("Helligkeit/lux: "); Serial.print(lux); Serial.println();
          lux_string = "      " + String(Lux);
          int laenge = lux_string.length();
          lux_string = lux_string.substring(laenge -6,laenge);
          for (int m=0; m < zeilenzahl; m++)
            {if (zeile_pointer[m] == 72) {zeile_data[m] = lux_string;}}
             if (((Lux > (last_value_D[72] + delta_lux)) || (Lux < (last_value_D[72] - delta_lux)) 
                                                || complete_loop)) 

               {befehl="GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable+"lux"+"').State("+Lux+")";
                set_sysvar();

                last_value_D[72] = Lux;
               }
         } 
       } 
//***********************************************************************//behandlung SHT21 an SCL pin21 und SDA pin 20



//behandlung Temperatur- und Feuchtesensor an SCL pin21 und SDA pin 20
    if (iomodus_sht ==1)
      {if (millis() > next_Time[70])
         {next_Time[70] = next_Time[70] +10000;  //SHT nicht häufiger als alle 10s abfragen 
          if (sht.begin()) {status = sht.GetTemperature();}
          if (status) {delay(status); status = sht.GetTemperature(T);}

          if (status) {delay(status); status = sht.GetHumidity(H);}
          sht_string = "     " + String(H);




          laenge = sht_string.length();
          sht_string = sht_string.substring(laenge -7,laenge -1);
          shtT_string = "      " + String(T);


          laenge = shtT_string.length();
          shtT_string = shtT_string.substring(laenge -7,laenge -1);

          for (int m=0; m < zeilenzahl; m++) {if (zeile_pointer[m] == 70) {zeile_data[m] = sht_string;}}
          if ((H > (last_sht_value + delta_sht)) || (H < (last_sht_value - delta_sht)) || complete_loop) 

            {befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"sht"+"').State("+H+")";
             set_sysvar();
             last_sht_value = H;

             last_value_D[70] = H;
            }

          for (int m=0; m < zeilenzahl; m++) {if (zeile_pointer[m] == 71) {zeile_data[m] = shtT_string;}}  
          if ((T > (last_shtT_value + delta_shtT)) || (H < (last_shtT_value - delta_shtT)) || complete_loop) 

            {befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"shtT"+"').State("+T+")";
             set_sysvar();
             last_shtT_value = T;

             last_value_D[71] = T;
            }
         }
      }
  }
//********************************************************************************​​*************


Ist es so besser?

Gruß
Johnny
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
06.04.2016, 12:59 (Dieser Beitrag wurde zuletzt bearbeitet: 06.04.2016 13:25 von hotsystems.)
Beitrag #4
RE: SHT21 in Sketch intigrieren
Ja, so ist es übersichtlicher.

Diese Anweisung wird schon als Fehler gemeldet.
Code:
SHT2x.h sht;

Ich vermute (Ich kenne den Sensor nicht) das dies so nicht funktioniert. Da gibt die Lib evtl. die Erstellung eines Objekts nicht her.

Du solltest dich an die Vorgaben im Testsketch halten.
Dazu müsstest du im Sketch in deinen Änderungen "sht." durch "SHT2x." tauschen können.

Bedingt durch die Komplexität des Sketches, kann ich den bei mir auch nicht kompilieren. Aber da fehlt bei mir sehr viel an Libraries.

Ich hoffe, das hilft weiter.

Edit:
Ich habe mit die Lib mal angesehen, evtl. funktioniert das so:

Code:
SHT2xClass sht;

In einem Testsketch konnte ich es kompilieren.

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
06.04.2016, 14:24
Beitrag #5
RE: SHT21 in Sketch intigrieren
(06.04.2016 12:59)hotsystems schrieb:  Ja, so ist es übersichtlicher.

Diese Anweisung wird schon als Fehler gemeldet.
Code:
SHT2x.h sht;

Ich vermute (Ich kenne den Sensor nicht) das dies so nicht funktioniert. Da gibt die Lib evtl. die Erstellung eines Objekts nicht her.

Du solltest dich an die Vorgaben im Testsketch halten.
Dazu müsstest du im Sketch in deinen Änderungen "sht." durch "SHT2x." tauschen können.

Bedingt durch die Komplexität des Sketches, kann ich den bei mir auch nicht kompilieren. Aber da fehlt bei mir sehr viel an Libraries.

Ich hoffe, das hilft weiter.

Edit:
Ich habe mit die Lib mal angesehen, evtl. funktioniert das so:

Code:
SHT2xClass sht;

In einem Testsketch konnte ich es kompilieren.

Muss ich später mal testen!

Ich hab mal den Sketch mit dem Beispielsketch vom SHT verglichen und da ist mir aufgefallen das bei dem Sketch von Eugen kein Wire.begin drin steht so wie es im Beispielsketch der Fall ist!
Muss das mit drin stehen?

Johnny
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
06.04.2016, 14:31
Beitrag #6
RE: SHT21 in Sketch intigrieren
(06.04.2016 14:24)PrinzEisenherz1 schrieb:  Ich hab mal den Sketch mit dem Beispielsketch vom SHT verglichen und da ist mir aufgefallen das bei dem Sketch von Eugen kein Wire.begin drin steht so wie es im Beispielsketch der Fall ist!
Muss das mit drin stehen?

Ich vermute mal nein, da dies schon in der Library erledigt wird.

Sonst einfach mal testen, ich kann es dank fehlender Hardware nicht testen.

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
06.04.2016, 14:38
Beitrag #7
RE: SHT21 in Sketch intigrieren
(06.04.2016 14:31)hotsystems schrieb:  
(06.04.2016 14:24)PrinzEisenherz1 schrieb:  Ich hab mal den Sketch mit dem Beispielsketch vom SHT verglichen und da ist mir aufgefallen das bei dem Sketch von Eugen kein Wire.begin drin steht so wie es im Beispielsketch der Fall ist!
Muss das mit drin stehen?

Ich vermute mal nein, da dies schon in der Library erledigt wird.

Sonst einfach mal testen, ich kann es dank fehlender Hardware nicht testen.

Ich werde es später mal testen! Trotzdem schon mal vielen Dank!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Sketch vom Arduino Board Herunterladen Sarius 2 351 27.07.2016 15:26
Letzter Beitrag: Sarius
  Sketch konnte nicht angelegt werden Sarius 2 241 16.07.2016 15:59
Letzter Beitrag: Sarius
Question Arduino Pro Micro verlangt keyboard.h im sketch weinema 0 315 01.03.2016 19:04
Letzter Beitrag: weinema
  Sketch läßt sich nicht hochladen - not in sync Stephan_56 20 1.779 17.01.2016 23:00
Letzter Beitrag: Bitklopfer
  Sketch VOM Mega IN die IDE holen? torsten_156 9 709 05.01.2016 15:41
Letzter Beitrag: René Hitz
  LED-Fade Sketch Hilgi 6 753 14.12.2015 11:00
Letzter Beitrag: Hilgi
  Eingänge im Programm integrieren Phil94 21 1.850 06.12.2015 10:52
Letzter Beitrag: hotsystems
  8x7 Segment LED Anzeige / Sketch verändern w1ck3d 3 653 23.11.2015 17:56
Letzter Beitrag: hotsystems
  Suche sketch mit der Abfrage von 2 oder mehr PIR's Tozupi 1 466 05.10.2015 20:55
Letzter Beitrag: hotsystems
  Problem mit GSM Sketch dahans 3 812 03.10.2015 18:15
Letzter Beitrag: dahans

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste