const String Version = "hduino415_LAN"; /*Stand: 14.11.2020 / Verfasser: Eugen Stall erprobt fuer Arduino Mega 2560 mit Arduino 1.8.13 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" < #include #include //für Temperatursensoren DS18B20 //http://www.hacktronics.com/code/OneWire.zip #include //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 //für I2C-Luxmeter //https://github.com/hexenmeister/AS_BH1750/archive/master.zip #include //für I2C-Barometer //https://github.com/sparkfun/BMP180_Breakout/archive/master.zip #include // läuft noch nicht! #include //#include // 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 // fuer cc3000 wifi // http://github.com/sparkfun/SFE_CC3000_Library/archive/master.zip #include // 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 EthernetClient client; EthernetServer server(80); #endif //************************************************************************************* #if defined(tft_display) //******************************************************************* #include //Quelle: https://github.com/adafruit/Adafruit-GFX-Library #include //Quelle: https://github.com/buhosoft/TFTLCD-Library #include #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 1 //3 oder 1 abhägig vom tft-shield typ < 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 < 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; i79) {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_ip, 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('"+ String(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('" + String(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("+ String(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("+ String(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("+ String(temp_tur) +")"; set_sysvar(); befehl="GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"D"+I+"_1').State("+ String(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("+ String(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("+ String(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("+ String(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("+ String(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 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("+ String(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("+ String(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("+ String(T) +")"; set_sysvar(); last_baroT_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('"+ String(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; befehl += " HTTP/1.1\r\nHost:"; //zusaetzlich wegen neuer CCU-firmware befehl += ccu_ip; befehl += "\r\nConnection: close\r\n\r\n"; if (client.connect(ccu_ip, 8181)) {Serial.print("sent to ccu : "); Serial.print(befehl); yield(); client.print(befehl); delay(10); client.stop(); ccu_presence = 1; } else {Serial.println("keine verbindung zur ccu"); ccu_presence = 0; return;} } //********************************************************************************************* 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 //*************************************************************************************