Schaltserver Arduino > ESP8266

  • Schaltserver Arduino > ESP8266

    @agent

    Hallo,

    hast Du vielleicht noch einen Sketch Schaltserver (mit 433 Mhz Sender / ohne 433 Mhz Sender) für den Arduino und ESP8266?

    Oder ist der veröffentlicht und ich habe ihn übersehen?

    Die Sketche (ESP8266) für DS18 und DHT habe ich mal zusammengeführt und auch einen 2. DHT eingetragen. Das verifizieren ist Fehlerfrei durchgelaufen. Hochgeladen habe ich ihn noch nicht.

    Mir ist noch unklar, wie der zweite DHT angeschlossen und Adressiert wird.

    Ich habe das mal so eingefügt:  Ist das so richtig?
    //Sonsorbelegungen für 2 DHT
    #define DHT_POWER_PIN 2 //Pin der den DHT ein/aus-schaltet
    #define DHT_PIN 3       //Pin an dem der DHT 1 Data Pin angeschlossen ist
    #define DHT_PIN 4       //Pin an dem der DHT 2 Data Pin angeschlossen ist

    Oder werden die Datenpin's parallel angeschlossen und die Adressierung wird über verschiedene DHT_Power Pin's gemacht?

    Den kompletten Sketch habe ich angehängt. Die Belegung des Speichers vom Arduino pro mini wäre dann mit 58 % belegt.

    Wäre es da möglich noch den Schaltserver ohne 433 Mhz Sender einzupflegen, da dieser wohl ca. 28 % Speicher belegt?

    Source Code

    1. /**
    2. * Sensorpunkt
    3. *
    4. * Benötigte Hardware:
    5. * - Arduino Uno, Mega, Due, Pro Mini oder Nano (für Pro Mini wird zum flashen noch ein FTDI/USB Adapter benötigt)
    6. * - ESP8266 WLAN Chip
    7. *
    8. * @author Oliver Kleditzsch
    9. * @copyright Copyright (c) 2015, Oliver Kleditzsch
    10. * @license http://opensource.org/licenses/gpl-license.php GNU Public License
    11. * @since 1.0.0
    12. * @version 1.0.0
    13. */
    15. #include "ESP8266.h"        //https://github.com/itead/ITEADLIB_Arduino_WeeESP8266
    16. #include <SoftwareSerial.h>
    17. #include <OneWire.h>
    18. #include <DallasTemperature.h> // https://github.com/milesburton/Arduino-Temperature-Control-Library
    19. #include <PString.h>
    20. #include <DHT.h>
    22. //WLan Verbindungsdaten
    23. #define SSID                "rmjspa" //SSID
    24. #define PASSWORD            "xxxyyyxxx" //Passwort
    25. #define HOST_NAME           "192.168.200.115" //IP des SHC Masters
    26. #define HOST_PORT           (80)
    27. #define USER_SEL_VERSION    VERSION_22
    29. //Allgemeine Einstellungen
    30. #define PRINT_ON_SERIAL 1 //Werte auch auf der Seriellen Schnittstelle ausgebe
    32. //Daten des Sensorpunktes
    33. #define POINT_ID 50   //ID des Sensorpunktes (muss zwischen 1 und 999 sein)
    35. //Sensorpunkt Spannung senden
    36. #define SEND_POINT_CURRENT 0  //Sensorpunkt Spannung Senden
    37. #define SEND_POINT_INDPUT A0  //Analogeingang für die Spannungsmessung
    39. //Verbindungs LED
    40. #define CONNECTED_LED 5       //Leuchtet solange die WLAN Verbindung aufgebaut ist
    42. //Sensor Typen
    43. //0 -> nicht Verwendet
    44. //1 -> DS18x20
    45. //2 -> DHT11/22
    46. //3 -> BMP085/180
    47. //4 -> Regensensor (Analogwert)
    48. //5 -> Feuchtigkeitssensor (Analogwert)
    49. //6 -> LDR (Analogwert)
    50. #define SENSOR_1_TYPE 0 //Typ des ersten Sensors (0 wenn deaktiviert)
    51. #define SENSOR_1_ID 51   //ID des ersten Sensors (muss Zwischen 1 und 998 sein und Systemweit eindeutig)
    52. #define SENSOR_2_TYPE 2
    53. #define SENSOR_2_ID 52
    54. #define SENSOR_3_TYPE 2
    55. #define SENSOR_3_ID 53
    56. #define SENSOR_4_TYPE 0
    57. #define SENSOR_4_ID 00
    58. #define SENSOR_5_TYPE 0
    59. #define SENSOR_5_ID 00
    60. #define SENSOR_6_TYPE 0
    61. #define SENSOR_6_ID 00
    63. //Sonsorbelegungen
    64. #define ONE_WIRE_BUS 8          //Daten Pin des DS18x20
    65. #define TEMPERATURE_PRECISION 9
    67. //DS18x20 Initialisieren
    68. OneWire oneWire(ONE_WIRE_BUS);
    69. DallasTemperature sensors(&oneWire);
    70. DeviceAddress sensor1, sensor2;
    72. //Sonsorbelegungen für 2 DHT
    73. #define DHT_POWER_PIN 2 //Pin der den DHT ein/aus-schaltet
    74. #define DHT_PIN 3       //Pin an dem der DHT 1 Data Pin angeschlossen ist
    75. #define DHT_PIN 4       //Pin an dem der DHT 2 Data Pin angeschlossen ist
    77. //DTH Initalisieren
    78. // Connect pin 1 (on the left) of the sensor to +5V
    79. // Connect pin 2 of the sensor to whatever your DHTPIN is
    80. // Connect pin 4 (on the right) of the sensor to GROUND
    81. // Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
    82. DHT dht;
    84. //WLan Initalisieren
    85. SoftwareSerial mySerial(9, 8); /* RX:D9, TX:D8 */
    86. ESP8266 wifi(mySerial, 9600);  //bei manchen auch 115200
    87. char host[] = "192.168.200.115"; //IP des SHC Masters
    88. char url[] = "/shc/index.php?app=shc&a&ajax=pushsensorvalues&"; //? oder & am Ende um dem Query String weiter zu fuehren
    90. void setup(void) {
    91.    
    92.  //Grundkonfiguration
    93.  if(PRINT_ON_SERIAL) {
    94.    
    95.    Serial.begin(9600);
    96.    Serial.println("WLan verbinden start");
    97.  }
    98.  
    99.  //Verbindungs LED
    100.  if(CONNECTED_LED > -1) {
    101.    
    102.     pinMode(CONNECTED_LED, OUTPUT);
    103.  }
    104.    
    105.  //Firmware Version
    106.  if(PRINT_ON_SERIAL) {
    107.    
    108.    Serial.print("FW Version: ");
    109.    Serial.println(wifi.getVersion().c_str());
    110.  }
    111.    
    112.  //WLan Modus setzen
    113.  if (wifi.setOprToStation()) {
    114.      
    115.    if(PRINT_ON_SERIAL) {
    116.      
    117.      Serial.println("Client OK");
    118.    }
    119.  } else {
    120.      
    121.    if(PRINT_ON_SERIAL) {
    122.      
    123.      Serial.println("Client Error");
    124.      while(1);
    125.    }
    126.  }
    128.  //mit AccessPoint verbinden
    129.  if (wifi.joinAP(SSID, PASSWORD)) {
    130.      
    131.    if(PRINT_ON_SERIAL) {
    132.      
    133.      Serial.println("erfolgreich mit dem AccessPoint verbunden");
    134.      Serial.print("IP: ");      
    135.      Serial.println(wifi.getLocalIP().c_str());
    136.    }
    137.  } else {
    138.      
    139.    if(PRINT_ON_SERIAL) {
    140.      
    141.      Serial.println("verbindung zum AccessPoint fehlgeschlagen");
    142.      while(1);
    143.    }
    144.  }
    145.    
    146.  if (wifi.disableMUX()) {
    147.    
    148.    if(PRINT_ON_SERIAL) {
    149.      
    150.      Serial.println("Single Modus OK");
    151.    }
    152.  } else {
    153.    
    154.    if(PRINT_ON_SERIAL) {
    155.      
    156.      Serial.println("Single Modus Error");
    157.      while(1);
    158.    }
    159.  }
    160.    
    161.  if(PRINT_ON_SERIAL) {
    162.    
    163.    Serial.println("Verbindung erfolgreich hergestellt");
    164.    Serial.println("");
    165.  }
    166.  
    167.  if(CONNECTED_LED > -1) {
    168.    
    169.     digitalWrite(CONNECTED_LED, HIGH);
    170.  }
    172.  //DS18x20 starten
    173.  sensors.begin();
    174. }
    177. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    178. // Hilfsfunktionen ///////////////////////////////////////////////////////////////////////////////////////////////
    179. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    181. //gibt den Wert des Sensors zurueck
    182. float printTemperature(DeviceAddress deviceAddress) {
    183.  
    184.  //Wert schreiben
    185.  float tempC = sensors.getTempC(deviceAddress);
    186.  return tempC;
    187. }
    189. void loop() {
    191. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    192. // Sende LED an //////////////////////////////////////////////////////////////////////////////////////////////////
    193. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    195. if(CONNECTED_LED > -1) {
    196.            
    197.  digitalWrite(CONNECTED_LED, HIGH);
    198. }
    200. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    201. // Sensor 1 Daten senden /////////////////////////////////////////////////////////////////////////////////////////
    202. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    204.  if(SENSOR_1_TYPE != 0) {
    206.    //DS18x20 lesen
    207.    sensors.requestTemperatures();
    208.    
    209.    for(int n = 0; n < sensors.getDeviceCount(); n++) {
    210.    if(sensors.getAddress(sensor1, n)) {
    211.      
    212.      //Puffer
    213.      char buffer1[20];
    214.      PString address(buffer1, sizeof(buffer1), "");
    215.      
    216.      //Adresse schreiben
    217.      address.print(sensor1[0], HEX);
    218.      address.print("-");
    219.      for (uint8_t i = 1; i < 8; i++) {
    220.        
    221.        // zero pad the address if necessary
    222.        if (sensor1[i] < 16) address.print("0");
    223.          address.print(String(sensor1[i], HEX));
    224.      }
    226.    //Daten Senden
    227.    if(wifi.createTCP(HOST_NAME, HOST_PORT)) {
    228.        
    229.      if(PRINT_ON_SERIAL) {
    230.        
    231.        Serial.println("verbunden");
    232.      }
    233.      
    234.      char buffer1[512];
    235.      PString request1(buffer1, sizeof(buffer1), "");
    236.      
    237.      //Anfrage senden
    238.      request1.print("GET ");
    239.      request1.print(url);
    240.      request1.print("spid=");
    241.      request1.print(POINT_ID);
    242.      request1.print("&sid=");
    243.      request1.print(SENSOR_2_ID);
    244.      request1.print("&type=");
    245.      request1.print(SENSOR_2_TYPE);
    246.      request1.print("&v1=");
    247.      request1.print(printTemperature(sensor1));
    248.      request1.println(" HTTP/1.1");
    249.      request1.print("Host: ");
    250.      request1.println(host);
    251.      request1.println();
    252.      request1.println();
    253.      
    254.      //Daten senden
    255.      const char *req1 = request1;
    256.      wifi.send((const uint8_t*)req1, strlen(req1));
    257.      
    258.      //TCP verbindung trennen
    259.      wifi.releaseTCP();
    260.        
    261.    } else {
    262.        
    263.      if(PRINT_ON_SERIAL) {
    264.        
    265.        Serial.println("Verbindung Fehlgeschlagen");
    266.      }
    267.    }
    268.      
    269.      if(PRINT_ON_SERIAL) {
    270.        
    271.          Serial.print("Sensor: ");
    272.          Serial.println(address);
    273.          Serial.print("Temperatur: ");
    274.          Serial.print(printTemperature(sensor1));
    275.          Serial.println("C");
    276.          Serial.println("");
    277.       }
    278.    }
    279.  }
    280.  }
    282. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    283. // Sensor 2 Daten senden /////////////////////////////////////////////////////////////////////////////////////////
    284. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    286.  if(SENSOR_2_TYPE != 0) {
    287.    
    288.    uint8_t buffer[1024] = {0};
    289.    digitalWrite(DHT_POWER_PIN, HIGH);
    290.    delay(2500);
    291.  
    292.    float temperature = dht.getTemperature();
    293.    float humidity = dht.getHumidity();
    294.    
    295.    //Daten Senden
    296.    if(wifi.createTCP(HOST_NAME, HOST_PORT)) {
    297.        
    298.      if(PRINT_ON_SERIAL) {
    299.        
    300.        Serial.println("verbunden");
    301.      }
    302.      
    303.      char buffer1[512];
    304.      PString request1(buffer1, sizeof(buffer1), "");
    305.      
    306.      //Anfrage senden
    307.      request1.print("GET ");
    308.      request1.print(url);
    309.      request1.print("spid=");
    310.      request1.print(POINT_ID);
    311.      request1.print("&sid=");
    312.      request1.print(SENSOR_1_ID);
    313.      request1.print("&type=");
    314.      request1.print(SENSOR_1_TYPE);
    315.      request1.print("&v1=");
    316.      request1.print(temperature);
    317.      request1.print("&v2=");
    318.      request1.print(humidity);
    319.      request1.println(" HTTP/1.1");
    320.      request1.print("Host: ");
    321.      request1.println(host);
    322.      request1.println();
    323.      request1.println();
    324.      
    325.      //Daten senden
    326.      const char *req1 = request1;
    327.      wifi.send((const uint8_t*)req1, strlen(req1));
    328.      
    329.      //TCP verbindung trennen
    330.      wifi.releaseTCP();
    331.        
    332.    } else {
    333.        
    334.      if(PRINT_ON_SERIAL) {
    335.        
    336.        Serial.println("Verbindung Fehlgeschlagen");
    337.      }
    338.    }
    339.    
    340.    if(PRINT_ON_SERIAL) {
    341.        
    342.        Serial.print("Temperatur: ");
    343.        Serial.print(temperature);
    344.        Serial.println("*C");
    345.        Serial.print("Luftfeuchte: ");
    346.        Serial.print(humidity);
    347.        Serial.println("%");
    348.        Serial.println("");
    349.     }
    350.    
    351.    //Sensor ausschalten
    352.    digitalWrite(DHT_POWER_PIN, LOW);
    353.  }
    355.  
    356. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    357. // Sensor 3 Daten senden /////////////////////////////////////////////////////////////////////////////////////////
    358. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    360.  if(SENSOR_3_TYPE != 0) {
    361.    
    362.    uint8_t buffer[1024] = {0};
    363.    digitalWrite(DHT_POWER_PIN, HIGH);
    364.    delay(2500);
    365.  
    366.    float temperature = dht.getTemperature();
    367.    float humidity = dht.getHumidity();
    368.    
    369.    //Daten Senden
    370.    if(wifi.createTCP(HOST_NAME, HOST_PORT)) {
    371.        
    372.      if(PRINT_ON_SERIAL) {
    373.        
    374.        Serial.println("verbunden");
    375.      }
    376.      
    377.      char buffer1[512];
    378.      PString request1(buffer1, sizeof(buffer1), "");
    379.      
    380.      //Anfrage senden
    381.      request1.print("GET ");
    382.      request1.print(url);
    383.      request1.print("spid=");
    384.      request1.print(POINT_ID);
    385.      request1.print("&sid=");
    386.      request1.print(SENSOR_1_ID);
    387.      request1.print("&type=");
    388.      request1.print(SENSOR_1_TYPE);
    389.      request1.print("&v1=");
    390.      request1.print(temperature);
    391.      request1.print("&v2=");
    392.      request1.print(humidity);
    393.      request1.println(" HTTP/1.1");
    394.      request1.print("Host: ");
    395.      request1.println(host);
    396.      request1.println();
    397.      request1.println();
    398.      
    399.      //Daten senden
    400.      const char *req1 = request1;
    401.      wifi.send((const uint8_t*)req1, strlen(req1));
    402.      
    403.      //TCP verbindung trennen
    404.      wifi.releaseTCP();
    405.        
    406.    } else {
    407.        
    408.      if(PRINT_ON_SERIAL) {
    409.        
    410.        Serial.println("Verbindung Fehlgeschlagen");
    411.      }
    412.    }
    413.    
    414.    if(PRINT_ON_SERIAL) {
    415.        
    416.        Serial.print("Temperatur: ");
    417.        Serial.print(temperature);
    418.        Serial.println("*C");
    419.        Serial.print("Luftfeuchte: ");
    420.        Serial.print(humidity);
    421.        Serial.println("%");
    422.        Serial.println("");
    423.     }
    424.    
    425.    //Sensor ausschalten
    426.    digitalWrite(DHT_POWER_PIN, LOW);
    427.  }
    429.  
    430. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    431. // Sensor 4 Daten senden /////////////////////////////////////////////////////////////////////////////////////////
    432. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    434. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    435. // Sensor 5 Daten senden /////////////////////////////////////////////////////////////////////////////////////////
    436. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    438. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    439. // Sensor 6 Daten senden /////////////////////////////////////////////////////////////////////////////////////////
    440. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    442. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    443. // Sensorpunkt Spannung senden ///////////////////////////////////////////////////////////////////////////////////
    444. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    446. if(SEND_POINT_CURRENT) {
    448.    //Betriebsspannung ermitteln
    449.    float voltage = analogRead(SEND_POINT_INDPUT) * (14.5 / 1023.0);  
    450.    
    451.    //Daten Senden
    452.    if(wifi.createTCP(HOST_NAME, HOST_PORT)) {
    453.        
    454.      if(PRINT_ON_SERIAL) {
    455.        
    456.        Serial.println("verbunden");
    457.      }
    458.      
    459.      if(CONNECTED_LED > -1) {
    460.            
    461.        digitalWrite(CONNECTED_LED, HIGH);
    462.      }
    463.      
    464.      char buffer7[512];
    465.      PString request7(buffer7, sizeof(buffer7), "");
    466.      
    467.      //Anfrage senden
    468.      request7.print("GET ");
    469.      request7.print(url);
    470.      request7.print("spid=");
    471.      request7.print(POINT_ID);
    472.      request7.print("&type=");
    473.      request7.print(999);
    474.      request7.print("&v1=");
    475.      request7.print(voltage);;
    476.      request7.println(" HTTP/1.1");
    477.      request7.print("Host: ");
    478.      request7.println(host);
    479.      request7.println();
    480.      request7.println();
    481.      
    482.      const char *req7 = request7;
    483.      wifi.send((const uint8_t*)req7, strlen(req7));
    484.      
    485.      //TCP verbindung trennen
    486.      wifi.releaseTCP();
    487.        
    488.    } else {
    489.        
    490.      if(PRINT_ON_SERIAL) {
    491.        
    492.        Serial.println("Verbindung Fehlgeschlagen");
    493.      }
    494.    
    495.    }
    496.    
    497.    if(PRINT_ON_SERIAL) {
    498.        
    499.        Serial.print("Voltage ");
    500.        Serial.print(voltage);
    501.        Serial.println("V");
    502.        Serial.println("");
    503.      }
    504. }
    506. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    507. // Sende LED aus /////////////////////////////////////////////////////////////////////////////////////////////////
    508. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    510. if(CONNECTED_LED > -1) {
    511.            
    512.  digitalWrite(CONNECTED_LED, LOW);
    513. }
    515. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    516. // Verweilzeit bis zum nächsten Sendevorgang /////////////////////////////////////////////////////////////////////
    517. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    519.  delay(60000);  
    520. }
    Display All
    SHC Master B2+ WLAN sowie 1 Slave B2+, 2 Slave B+ und 2 Slave Raspi B. 5x Pi Cam; Imac mit OSX El Capitan; Iphone 6 plus; Ipad mini; Lenovo Android Tablet.

  • RE: Schaltserver Arduino &gt; ESP8266

    rmjspa wrote:


    Mir ist noch unklar, wie der zweite DHT angeschlossen und Adressiert wird.

    Ich habe das mal so eingefügt:  Ist das so richtig?
    //Sonsorbelegungen für 2 DHT
    #define DHT_POWER_PIN 2 //Pin der den DHT ein/aus-schaltet
    #define DHT_PIN 3       //Pin an dem der DHT 1 Data Pin angeschlossen ist
    #define DHT_PIN 4       //Pin an dem der DHT 2 Data Pin angeschlossen ist


    ich kann das nicht genau sagen, aber wenn ich das richtig verstanden habe müssen für die verschiedenen DHT, verschiedene Instanzen eingetragen sein. wie zB so:

    //Sonsorbelegungen für 2 DHT
    #define DHT1_POWER_PIN 2 //Pin der den DHT 1 ein/aus-schaltet
    #define DHT1_PIN 3       //Pin an dem der DHT 1 Data Pin angeschlossen ist
    #define DHT2_POWER_PIN 5 //Pin der den DHT 2 ein/aus-schaltet
    #define DHT2_PIN 4       //Pin an dem der DHT 2 Data Pin angeschlossen ist

    natürlich durch den ganzen sketch.
    Gruß

    Matthias
    1x RasPi b, 3x RasPi b+, 1x RasPi 2, 2x RasPi 3, 2x RasPi Zero, 1x RadPi 4 (4GB) 1x BananaPi M1, 1x BananaPi R1, 1x BananaPi M3, 2x OrangePi Zero, 1x OrangePi One

    BTC: 1AJgWX9SXzH6wpoQ9d5HpkLcct6kAuatvJ
    NMC: N9fF4858aVWpY3Zu5xSxBV4XLvZ73D8eKV

  • RE: Schaltserver Arduino > ESP8266

    So wie adm1n geschrieben hat benötigst du mindestens für jeden DHT einen eigenen Datenpin. Die Power Pins kannst du wenn wenn du willst zusammen legen, musst dann aber aufpassen der der Power Pin erst nach dem 2. DHT wieder auf LOW geschalten wird.

    Du kannst generell keinen Schaltserver und Sensorsender auf einem Arduino kombinieren, du kannst höchstens 2 Arduinos auf eine Platine löten. Die Arduinos laufen nur Single Threaded und können keine 2 Prozesse gleichzeitig behandeln. Einen ESP-Sketch für den Schaltserver habe ich noch nicht programmiert.

    The post was edited 1 time, last by agent47 ().

  • RE: Schaltserver Arduino &gt; ESP8266

    Danke euch für die Informationen.


    So wie adm1n geschrieben hat benötigst du mindestens für jeden DHT einen eigenen Datenpin.


    Das dachte ich mir, wusste bloß nicht wie ich das dem Sketch beibringe.

    Der POWER_PIN wird meines Erachtens erst im Batteriebetrieb interessant. Mit Netzteil ist es doch egal ob der DHT ständig bestromt wird.


    Du kannst generell keinen Schaltserver und Sensorsender auf einem Arduino kombinieren, du kannst höchstens 2 Arduinos auf eine Platine löten.


    Gut zu wissen, da hätte ich jetzt noch tagelang herum probiertl.

    @gMaN

    Du kannst ja aber den Tcp Server laufen lassen und mittels Timer alle x sek die sensor Daten an shc senden mit einen arduino


    Hast Du dafür ein Beispiel? Wäre das dann als .lua oder als .ino Sketch. Soweit ich das bisher gelesen habe ist das hochladen eines .lua Sketches von einem IMAC eine größere Angelegenheit.  Das hochladen von .ino Dateien mit dem Arduino Program läuft vom IMAC aus einfach.
    SHC Master B2+ WLAN sowie 1 Slave B2+, 2 Slave B+ und 2 Slave Raspi B. 5x Pi Cam; Imac mit OSX El Capitan; Iphone 6 plus; Ipad mini; Lenovo Android Tablet.

  • Das ist eine gute Frage und erinnert mich an etwas, was ich schon vor einiger Zeit sagen wollte.

    Anhand der Zugriffszahlen sieht man wie beliebt die Themen um den ESP und Arduino sind.

    Es gibt auch etliche Leute hier im Forum, die Sketche geschrieben oder modifiziert haben für alle möglichen Anwendungen.

    Leider sind bisher noch keine hier im Downloadbereich gelandet, sondern müssen, soweit vorhanden zwischen den einzelnen Beiträgen gesucht werden.

    Schön wäre es, wenn diese gebündelt mit kurzer Beschreibung im Downloadbereich zu finden wären.
    SHC Master B2+ WLAN sowie 1 Slave B2+, 2 Slave B+ und 2 Slave Raspi B. 5x Pi Cam; Imac mit OSX El Capitan; Iphone 6 plus; Ipad mini; Lenovo Android Tablet.

  • es ist super wenn das zB mit einem esp8266_12 funktioniert, aber das wäre eine ESP Variante. eine Arduino <-> ESP Variante ist mir leider gerade nicht bekannt, wäre aber die "schönere" Variante wie einfach einen ESP als schaltserver zu nutzen. der sinn der sich meiner Meinung nach daraus ergibt ist das ich je nach platz und pin bedarf einfach den Arduino austausche. mit ist kein ESP bekannt der so viele pins hat wie ein Arduino mega.
    Gruß

    Matthias
    1x RasPi b, 3x RasPi b+, 1x RasPi 2, 2x RasPi 3, 2x RasPi Zero, 1x RadPi 4 (4GB) 1x BananaPi M1, 1x BananaPi R1, 1x BananaPi M3, 2x OrangePi Zero, 1x OrangePi One

    BTC: 1AJgWX9SXzH6wpoQ9d5HpkLcct6kAuatvJ
    NMC: N9fF4858aVWpY3Zu5xSxBV4XLvZ73D8eKV

  • Der einzige, der mir einfällt ist, dass der Arduino noch vielleicht 2 GPIO's mehr hat, da müsste ich nachzählen und er hat eben Analogeingänge.

    Im Prinzip hast Du recht Premo, für die meisten Anwendungen sollte der ESP-12 ausreichen. GPIO's lassen sich mit dem Sketche lesen und schreiben.
    SHC Master B2+ WLAN sowie 1 Slave B2+, 2 Slave B+ und 2 Slave Raspi B. 5x Pi Cam; Imac mit OSX El Capitan; Iphone 6 plus; Ipad mini; Lenovo Android Tablet.

  • Du hast doch den Arduino mit ESP als Sensortransmitter hinbekommen, kann man da nicht Rückschlüsse auf den Schaltserver ziehen?

    Auf der anderen Seite, gibt es einen funktionierenden Sketch für den Arduino mit LAN Adapter. Vielleicht lassen sich da auch wieder Rückschlüsse ziehen.

    Aber, ich denke mal, dass Du das schon ausgelotet hast.
    SHC Master B2+ WLAN sowie 1 Slave B2+, 2 Slave B+ und 2 Slave Raspi B. 5x Pi Cam; Imac mit OSX El Capitan; Iphone 6 plus; Ipad mini; Lenovo Android Tablet.

  • Zwischen dem LAN Senden und dem WLan Senden sind grosse Unterschiede.

    Bei Lan wird per Print gesendet, bei wlan musst erst n arree aufbauen.

    Das Problem was ich habe ist erst mal überhaupt zu verstehen wie das mit den Schaltservern geht. Die werden ja vom SHC irgendwie abgefragt.
    Sensorsender senden blind drauf los.

    Bin grad dabei ein 433mhz reseiver am arduino zur erkennung der Fernbedienungen / Funk PIR ... zu stricken. Das senden zum SHC als Sensorsender geht auch schon. (aber der SHC ignoriert es, weil ja keine Zuordnung).

    Jetzt bräuchte ich nur ne Schnittstelle, wo man dem ESP die FB Codierung mitteilen könnte, sodas man mit Ereignissen dadrauf regieren kann. Ich mag das PiLight nicht zum empfangen im SHC. Das überlastet sinnloserweise das System. Und n Arduino mit ESP kann überall zum zentralen Einsammeln der Daten liegen.

    (Im Prinzip das was unserer nerv... Burkh... will.)
    habe SHC aufgegeben.

    The post was edited 2 times, last by bin dann weg ().

  • C-3po wrote:

    Jetzt bräuchte ich nur ne Schnittstelle, wo man dem ESP die FB Codierung mitteilen könnte, sodas man mit Ereignissen dadrauf regieren kann. Ich mag das PiLight nicht zum empfangen im SHC. Das überlastet sinnloserweise das System. Und n Arduino mit ESP kann überall zum zentralen Einsammeln der Daten liegen.
    Habe vor ein paar Tagen das gefunden: Decode 433 MHz signals w/ Arduino & 433 MHz Receiver | PrinceTronics

    Aber, dass kennst Du vielleicht schon.

    Den pilight mag ich auch nicht.
    SHC Master B2+ WLAN sowie 1 Slave B2+, 2 Slave B+ und 2 Slave Raspi B. 5x Pi Cam; Imac mit OSX El Capitan; Iphone 6 plus; Ipad mini; Lenovo Android Tablet.