Schaltserver Arduino > ESP8266

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • 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?

    Quellcode

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


    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.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von 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.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von bin dann weg ()

  • C-3po schrieb:

    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.