[PORADNIK] Arduino IDE

Benon
Posts: 30
Joined: Tue Jan 15, 2019 8:17 am

Thu Feb 07, 2019 12:23 am

Odkopię trochę post. Wgrałem soft z tego postu do Wemos D1 R2 i nie loguje się do cloud. W cloudzie ustawiona jest rejestracja nowych urządzeń. Po wpisaniu wszystkiego w 192.168.4.1 dane się zapisują, AP wyłącza się i włącza ponownie. SSID to "Supla AP". Gdzie szukać problemu? Któreś biblioteki?
cino111
Posts: 346
Joined: Mon May 07, 2018 8:00 pm

Thu Feb 07, 2019 11:24 am

Benon wrote:
Thu Feb 07, 2019 12:23 am
Odkopię trochę post. Wgrałem soft z tego postu do Wemos D1 R2 i nie loguje się do cloud. W cloudzie ustawiona jest rejestracja nowych urządzeń. Po wpisaniu wszystkiego w 192.168.4.1 dane się zapisują, AP wyłącza się i włącza ponownie. SSID to "Supla AP". Gdzie szukać problemu? Któreś biblioteki?
Jaki wgrałeś konkretnie soft? Co potrzebujesz i jaką masz wersję biblioteki do ESP? Wygląda na to, że najlepiej działa 2.3.0
Benon
Posts: 30
Joined: Tue Jan 15, 2019 8:17 am

Fri Feb 08, 2019 12:13 am

Jeszcze nie udało mi się wgrać przez Arduino IDE kompletnie nic co by działało (zarejestrowało się w cloudzie). Pliki *.bin bez problemu ale brak kontroli nad pinami. Mam Wemosy d1, ktore oferują 11 gpio. Chciałbym prócz buttonów, relayów, sensorów i ledów dodać czujniki otwarcia, buzzer potwierdzający zadziałanie buttona, timing w różnej konfiguracji... ach.
Opanowałem możliwości Domoticza i EspEasy i tam wszystko jest wykonalne ale chciałbym pozostać przy Supli.

To kod z tego tematu.

Code: Select all

#include <FS.h>  

#include <ESP8266WiFi.h>
#define SUPLADEVICE_CPP
#include <SuplaDevice.h>

#include <ESP8266WebServer.h>
#include <DNSServer.h>
#include <WiFiManager.h> 
#include <ArduinoJson.h>

#include <OneWire.h>
#include <DallasTemperature.h>
int button1 = 0; //wartosc początkowa dla przycisku 1

WiFiClient client;

OneWire oneWire(4); //  (D2) - Pin number
DallasTemperature sensors(&oneWire);

DeviceAddress garaz = { 0x28, 0xFF, 0x2E, 0xFB, 0xC1, 0x17, 0x1, 0xD3 };       // odczytany adres 28FF2EFBC11701D3  
DeviceAddress zewnatrz = { 0x28, 0xFF, 0xEC, 0xFE, 0xC1, 0x17, 0x1, 0xF3 };     //Odczytany adres 28FFECFEC11701F3 

//define your default values here, if there are different values in config.json, they are overwritten.
//length should be max size + 1 
char Supla_server[40];
char Location_id[15];
char Location_Pass[20];
byte mac[6];

//flag for saving data
bool shouldSaveConfig = false;
bool initialConfig = false;

#define TRIGGER_PIN D3
int timeout           = 5000; // szas otwarica config po resecie ESP

//callback notifying us of the need to save config
void saveConfigCallback () {
  Serial.println("Should save config");
  shouldSaveConfig = true;
}
void ondemandwifiCallback () {
// The extra parameters to be configured (can be either global or just in the setup)
  // After connecting, parameter.getValue() will get you the configured value
  // id/name placeholder/prompt default length
  WiFiManagerParameter custom_Supla_server("server", "supla server", Supla_server, 40);
  WiFiManagerParameter custom_Location_id("ID", "Location_id", Location_id, 15);
  WiFiManagerParameter custom_Location_Pass("Password", "Location_Pass", Location_Pass, 20);

  //WiFiManager
  //Local intialization. Once its business is done, there is no need to keep it around
  WiFiManager wifiManager;

  //set config save notify callback
  wifiManager.setSaveConfigCallback(saveConfigCallback);
  
  //add all your parameters here
  wifiManager.addParameter(&custom_Supla_server);
  wifiManager.addParameter(&custom_Location_id);
  wifiManager.addParameter(&custom_Location_Pass);

  //set minimu quality of signal so it ignores AP's under that quality
  //defaults to 8%
  wifiManager.setMinimumSignalQuality();

  // set configportal timeout
    wifiManager.setConfigPortalTimeout(timeout);

    if (!wifiManager.startConfigPortal("SuplaAP")) {
      Serial.println("failed to connect and hit timeout");
      delay(3000);
      //reset and try again, or maybe put it to deep sleep
      ESP.restart();
      delay(5000);
    }
    //if you get here you have connected to the WiFi
    Serial.println("connected...yeey :)");
    
    //read updated parameters
    strcpy(Supla_server, custom_Supla_server.getValue());
    strcpy(Location_id, custom_Location_id.getValue());
    strcpy(Location_Pass, custom_Location_Pass.getValue());
  
}

// DS18B20 Sensor read implementation
double get_temperature(int channelNumber, double last_val) {
      
    double t = -275;
    
    if ( sensors.getDeviceCount() > 0 )
      {
         sensors.requestTemperatures();
         switch(channelNumber)

          {
            case 0:
                   
                    t = sensors.getTempC(garaz);
                    break;
            case 1:
                    t = sensors.getTempC(zewnatrz);
                    break;
          
             };
      };

    
    return t;  
}

void setup() {

  Serial.begin(115200);

 pinMode (16, INPUT_PULLUP); //ustawiamy Pin 16 (D0) na przycisk

   // Init DS18B20 library 
  sensors.begin();
  
    // Set temperature callback
  SuplaDevice.setTemperatureCallback(&get_temperature);
  
  

  pinMode(TRIGGER_PIN, INPUT);
  
  if (WiFi.SSID()==""){
    //Serial.println("We haven't got any access point credentials, so get them now");   
    initialConfig = true;
  }
  
  //read configuration from FS json
  Serial.println("mounting FS...");
  
  if (SPIFFS.begin()) {
    Serial.println("mounted file system");
    if (SPIFFS.exists("/config.json")) {
      //file exists, reading and loading
      Serial.println("reading config file");
      File configFile = SPIFFS.open("/config.json", "r");
      if (configFile) {
        Serial.println("opened config file");
        size_t size = configFile.size();
        // Allocate a buffer to store contents of the file.
        std::unique_ptr<char[]> buf(new char[size]);

        configFile.readBytes(buf.get(), size);
        DynamicJsonBuffer jsonBuffer;
        JsonObject& json = jsonBuffer.parseObject(buf.get());
        json.printTo(Serial);
        if (json.success()) {
         // Serial.println("\nparsed json");

          strcpy(Supla_server, json["Supla_server"]);
          strcpy(Location_id, json["Location_id"]);
          strcpy(Location_Pass, json["Location_Pass"]);

        } else {
          Serial.println("failed to load json config");
          
        }
      }
    }
    WiFi.softAPdisconnect(true); // wyłączenie rozglaszania Wifi ESP po połaczeniu do lokalnego WIFI
  } else {
    Serial.println("failed to mount FS");
  }
  //end read
  //Serial.println(Location_id);
  //Serial.println(Location_Pass);
  //Serial.println(Supla_server);
 
 delay(10);
 
   char GUID[SUPLA_GUID_SIZE] ={0x53,0x9C,0x2D,0x21,0x2F,0xB2,0xB9,0x40,0x71,0xAD,0xA8,0xCD,0x39,0xC7,0x34,0x4D}; 
   // with GUID that you can retrieve from https://www.supla.org/arduino/get-guid.
   WiFi.macAddress(mac);

  
  // CHANNEL0 - Thermometer DS18B20
  SuplaDevice.addDS18B20Thermometer();

   // CHANNEL1 - Thermometer DS18B20
  SuplaDevice.addDS18B20Thermometer();


  
  
  // CHANNEL2 - RELAY
  SuplaDevice.addRelay(D5, true);          

  // CHANNEL3 - RELAY
  SuplaDevice.addRelay(D6, true);            

   // CHANNEL4 - RELAY
  SuplaDevice.addRelay(D7, true);  

 

  
  // CHANNEL5 - Opening sensor (Normal Open)
  SuplaDevice.addSensorNO(A0); // A0 - Pin number where the sensor is connected
                               // Call SuplaDevice.addSensorNO(A0, true) with an extra "true" parameter
                               // to enable the internal pull-up resistor





  // CHANNEL6 - DHT22 Sensor
  // SuplaDevice.addDHT11();
  // SuplaDevice.addAM2302();
  // SuplaDevice.addDHT22();

  int LocationID = atoi(Location_id);
  SuplaDevice.begin(GUID,              // Global Unique Identifier 
                    mac,               // Ethernet MAC address
                    Supla_server,  // SUPLA server address
                    LocationID,                 // Location ID 
                    Location_Pass);               // Location Password
    
}

void loop() {

   // is configuration portal requested?
  if ( digitalRead(TRIGGER_PIN) == LOW|| (initialConfig))  {
    ondemandwifiCallback () ;
    initialConfig = false; 
  }
  //save the custom parameters to FS
  if (shouldSaveConfig) {
    Serial.println("saving config");
    DynamicJsonBuffer jsonBuffer;
    JsonObject& json = jsonBuffer.createObject();
    json["Supla_server"] = Supla_server;
    json["Location_id"] = Location_id;
    json["Location_Pass"] = Location_Pass;

    File configFile = SPIFFS.open("/config.json", "w");
    if (!configFile) {
      Serial.println("failed to open config file for writing");
    }
    json.prettyPrintTo(Serial);
    json.printTo(configFile);
    configFile.close();
    Serial.println("config saved");
    shouldSaveConfig = false;
    //end save
  }
  
  if (WiFi.status() != WL_CONNECTED) 
  {
    WiFi_up();
  }
 SuplaDevice.iterate();
 
   TSD_SuplaChannelNewValue przycisk1; //ustaw nazwe dla przycisku
  przycisk1.SenderID = 0; // Powiadom clouda, że załączasz recznie. W przypadku siłowników ma być 0
  przycisk1.ChannelNumber = 4; // nr kanału przekaźnika
  przycisk1.DurationMS = 0; //czas wlaczenia

button1 = digitalRead(16); 
if(digitalRead(16)==LOW){ // tu dodajemy jeszcze raz zeby nie pstrykalo samo czyli przerwa i ponowne zapytanie
  delay(100);
if(digitalRead(16)==LOW){
przycisk1.value[0] = !przycisk1.value[0]; 
SuplaDevice.channelSetValue(&przycisk1);
while(digitalRead(16)==LOW);
delay(20);
    }
  }
}


// Supla.org ethernet layer
    int supla_arduino_tcp_read(void *buf, int count) {
        _supla_int_t size = client.available();
       
        if ( size > 0 ) {
            if ( size > count ) size = count;
            return client.read((uint8_t *)buf, size);
        };
    
        return -1;
    };
    
    int supla_arduino_tcp_write(void *buf, int count) {
        return client.write((const uint8_t *)buf, count);
    };
    
    bool supla_arduino_svr_connect(const char *server, int port) {
          return client.connect(server, 2015);
    }
    
    bool supla_arduino_svr_connected(void) {
          return client.connected();
    }
    
    void supla_arduino_svr_disconnect(void) {
         client.stop();
    }
    
    void supla_arduino_eth_setup(uint8_t mac[6], IPAddress *ip) {

       WiFi_up();
    }
SuplaDeviceCallbacks supla_arduino_get_callbacks(void) {
          SuplaDeviceCallbacks cb;
          
          cb.tcp_read = &supla_arduino_tcp_read;
          cb.tcp_write = &supla_arduino_tcp_write;
          cb.eth_setup = &supla_arduino_eth_setup;
          cb.svr_connected = &supla_arduino_svr_connected;
          cb.svr_connect = &supla_arduino_svr_connect;
          cb.svr_disconnect = &supla_arduino_svr_disconnect;
          cb.get_temperature = &get_temperature;
           cb.get_temperature_and_humidity = NULL;
          cb.get_rgbw_value = NULL;
          cb.set_rgbw_value = NULL;
          
          return cb;
}

void WiFi_up() // Procedimiento de conexión para redes WiFi
{
  Serial.print("Conexión a la red ");
 // Serial.println(ssid);

  WiFi.begin(); // Intentar conectarse a la red


  for (int x = 60; x > 0; x--) 
  {
    if (WiFi.status() == WL_CONNECTED) 
    {
      break;                           
    }
    else                                 
    {
      Serial.print(".");                
      delay(500);                      
    }

  }

  if (WiFi.status() == WL_CONNECTED)
  {
    Serial.println("");
    Serial.println("Conexión hecha");
    Serial.println("Adres IP: ");
    Serial.print(WiFi.localIP());
    Serial.print(" / ");
    Serial.println(WiFi.subnetMask());
    Serial.print("puerta: ");
    Serial.println(WiFi.gatewayIP());
    long rssi = WiFi.RSSI();
    Serial.print("Fuerza de la señal (RSSI): ");
    Serial.print(rssi);
    Serial.println(" dBm");
  }
  else    
  {
    Serial.println("");
    Serial.println("La conexión no pudo hacerse");
  }
}
EDIT: biblioteka 2.5.0
cino111
Posts: 346
Joined: Mon May 07, 2018 8:00 pm

Sun Feb 10, 2019 5:11 pm

Pierwsze co to zainstaluj bibliotekę płytek w wersji 2.3.0
Kolejne to jeżeli robisz program dla siebie to czy na pewno potrzebujesz configurator? Pisząc w Arduino IDE najlepiej na stałe wpisać sieć wifi i dane serwera. Nie ma problemu z rozłączaniem się.
Masz tu przykładowy program z możliwością aktualizacji online, czyli pierwszy raz wgrywasz kablem, a potem online wchodząc na IP modułu.
Jezeli coś jeszcze potrzebujesz np przycisk to pisz.

Code: Select all

//  **************************************************************************************************************
//  * Kompilowane na Arduino 1.8.5 by@wojtas567                                                                               *
//  * Po odczytaniu adresów czujników należy je wpisać do tablicy wg poniższego wzoru                            *
//  * DeviceAddress jeden = { 0x28, 0xFF, 0xE8, 0x00, 0xB6, 0x16, 0x03, 0x65 };                                  *      
//  * DeviceAddress dwa = { 0x28, 0xFF, 0x54, 0x6F, 0xB3, 0x16, 0x05, 0xE9 };                                    *
//  * ...                                                                                                        *
//  *                                                                                                            *
//  * a na stępnie usunąć wiersze:                                                                               *
//  *        *    DeviceAddress jeden, dwa, trzy, cztery, piec, szesc, siedem, osiem;                            *
//  *                                                                                                            *
//  *        *    if (!sensors.getAddress(jeden, 0)) Serial.println("Nie można znaleźć adresu urządzenia 0");    *
//  *        *    if (!sensors.getAddress(dwa, 1)) Serial.println("Nie można znaleźć adresu urządzenia 1");      *
//  *        *    if (!sensors.getAddress(trzy, 2)) Serial.println("Nie można znaleźć adresu urządzenia 2");     *
//  *        *    if (!sensors.getAddress(cztery, 3)) Serial.println("Nie można znaleźć adresu urządzenia 3");   *
//  *        *    if (!sensors.getAddress(piec, 4)) Serial.println("Nie można znaleźć adresu urządzenia 4");     *
//  *        *    if (!sensors.getAddress(szesc, 5)) Serial.println("Nie można znaleźć adresu urządzenia 5");    *
//  *        *    if (!sensors.getAddress(siedem, 6)) Serial.println("Nie można znaleźć adresu urządzenia 6");   *
//  *        *    if (!sensors.getAddress(osiem, 7)) Serial.println("Nie można znaleźć adresu urządzenia 6");    *
//  *                                                                                                            *
//  **************************************************************************************************************


#include <ESP8266WiFi.h>
#define SUPLADEVICE_CPP
#include <SuplaDevice.h>

#include <ESP8266WebServer.h>
#include <DNSServer.h>
#include <ESP8266mDNS.h>
#include <ESP8266HTTPUpdateServer.h>
extern "C" {
#include "user_interface.h"
}
// Include the libraries we need
#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE 2
#define TEMPERATURE_PRECISION 10  // rozdzielczość czujnika DS 9 -12 bit

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

// tablica do przechowywania adresów urządzeń
//DeviceAddress jeden, dwa, trzy, cztery, piec, szesc, siedem, osiem;

// lub tu już wprowadzone

DeviceAddress jeden = { 0x28, 0xFF, 0xEC, 0xFE, 0xC1, 0x17, 0x1, 0xF3 };       // odczytany adres 28FF2EFBC11701D3  
DeviceAddress dwa = { 0x28, 0xFF, 0xEA, 0x16, 0xC2, 0x17, 0x1, 0xDE };     //Odczytany adres 28FFEA16C21701DE 
DeviceAddress trzy = { 0x28, 0xFF, 0xBC, 0xA, 0xC2, 0x17, 0x1, 0xFD };   // odczytany adres 28FFBC0AC21701FD
DeviceAddress cztery = { 0x28, 0xFF, 0x8, 0x7E, 0xC1, 0x17, 0x2, 0xD };   // odczytany adres 28FF087EC117020D
DeviceAddress piec = { 0x28, 0xFF, 0xCD, 0xCB, 0xC1, 0x17, 0x1, 0xF };   // odczytany adres 28FFCDCBC117010F
DeviceAddress szesc = { 0x28, 0xFF, 0xA9, 0x6A, 0xC1, 0x17, 0x2, 0xC5 };   // odczytany adres 28FFA96AC11702C5
DeviceAddress siedem = { 0x28, 0xFF, 0x8, 0xBF, 0xC1, 0x17, 0x1, 0x59 };   // odczytany adres 28FF08BFC1170159


// Setup Supla connection
const char* ssid     = "xxxxx";
const char* password = "xxxxx";

WiFiClient client;
const char* host = "supla";
const char* update_path = "/supla";
const char* update_username = "admin";
const char* update_password = "supla";

ESP8266WebServer httpServer(81);
ESP8266HTTPUpdateServer httpUpdater;

// DS18B20 Sensor read implementation
double get_temperature(int channelNumber, double last_val) {

    double t = -275;
          switch(channelNumber)
         {

            case 0:
         sensors.requestTemperatures();
         t = sensors.getTempC(jeden);
        Serial.print("Temp 1 : ");
        Serial.println(t);
                    break;
            case 1:
         t = sensors.getTempC(dwa);
        Serial.print("Temp 2 : ");
        Serial.println(t);
                    break;
            case 2:
         t = sensors.getTempC(trzy);
        Serial.print("Temp 3 : ");
        Serial.println(t);
                    break;
            case 3:
         t = sensors.getTempC(cztery);
        Serial.print("Temp 4 : ");
        Serial.println(t);
                    break;
            case 4:
         t = sensors.getTempC(piec);
        Serial.print("Temp 5 : ");
        Serial.println(t);
                    break;
            case 5:
         t = sensors.getTempC(szesc);
        Serial.print("Temp 6 : ");
        Serial.println(t);
                    break;
            case 6:
         t = sensors.getTempC(siedem);
        Serial.print("Temp 7 : ");
        Serial.println(t);
                    break;
            case 7:
         t = WiFi.RSSI();
        Serial.print("Temp 8 : ");
        Serial.println(t);
        Serial.println("***********GOTOWE*************");
                    break;
          }
         
    return t;  
}
                                 
// funkcja drukowania adresu urządzenia
void printAddress(DeviceAddress deviceAddress)
{
  for (uint8_t i = 0; i < 8; i++)
  {
    // zero pad the address if necessary
    if (deviceAddress[i] < 16) Serial.print("0");
    Serial.print(deviceAddress[i], HEX);
  }
}

void setup() {
  Serial.begin(115200);
  delay(10);

  wifi_station_set_hostname("Supla-piec");  //nazwa w sieci lokalnej
  WiFi.softAPdisconnect(true); // wyłączenie rozgłaszania sieci ESP

  // Inicjalizacja DS18B20
  sensors.begin();
  SuplaDevice.setTemperatureCallback(&get_temperature);

//******Odczyt DS wraz z adresami********************
  // zlokalizuj urządzenia na szynie danych
  Serial.print("Lokalizowanie urządzeń...");
  Serial.print(" znaleziono ");
  Serial.print(sensors.getDeviceCount(), DEC);
  Serial.println(" urządzeń.");

  // zgłosić zapotrzebowanie na moc pasożytniczą
  Serial.print("Zasilanie pasożytnicze jest: ");
  if (sensors.isParasitePowerMode()) Serial.println("ON");
  else Serial.println("OFF");
/*
  if (!sensors.getAddress(jeden, 0)) Serial.println("Nie można znaleźć adresu urządzenia 0");
  if (!sensors.getAddress(dwa, 1)) Serial.println("Nie można znaleźć adresu urządzenia 1");
  if (!sensors.getAddress(trzy, 2)) Serial.println("Nie można znaleźć adresu urządzenia 2");
  if (!sensors.getAddress(cztery, 3)) Serial.println("Nie można znaleźć adresu urządzenia 3");
  if (!sensors.getAddress(piec, 4)) Serial.println("Nie można znaleźć adresu urządzenia 4");
  if (!sensors.getAddress(szesc, 5)) Serial.println("Nie można znaleźć adresu urządzenia 5");
  if (!sensors.getAddress(siedem, 6)) Serial.println("Nie można znaleźć adresu urządzenia 6");
  if (!sensors.getAddress(osiem, 7)) Serial.println("Nie można znaleźć adresu urządzenia 6");
*/
  // pokaż adresy, które znaleźliśmy na szynie
  Serial.print("Adres Urządzenia 0: ");
  printAddress(jeden);
  Serial.println();

  Serial.print("Adres Urządzenia 1: ");
  printAddress(dwa);
  Serial.println();

  Serial.print("Adres Urządzenia 2: ");
  printAddress(trzy);
  Serial.println();

  Serial.print("Adres Urządzenia 3: ");
  printAddress(cztery);
  Serial.println();

  Serial.print("Adres Urządzenia 4: ");
  printAddress(piec);
  Serial.println();

  Serial.print("Adres Urządzenia 5: ");
  printAddress(szesc);
  Serial.println();

  Serial.print("Adres Urządzenia 6: ");
  printAddress(siedem);
  Serial.println();

  Serial.print("Adres Urządzenia 7: ");
 // printAddress(osiem);
  Serial.println();

  // ustaw rozdzielczość na 9 bitów na urządzeniach
  sensors.setResolution(jeden, TEMPERATURE_PRECISION);
  sensors.setResolution(dwa, TEMPERATURE_PRECISION);
  sensors.setResolution(trzy, TEMPERATURE_PRECISION);
  sensors.setResolution(cztery, TEMPERATURE_PRECISION);
  sensors.setResolution(piec, TEMPERATURE_PRECISION);
  sensors.setResolution(szesc, TEMPERATURE_PRECISION);
  sensors.setResolution(siedem, TEMPERATURE_PRECISION);
 // sensors.setResolution(osiem, TEMPERATURE_PRECISION);

  Serial.print("Rozdzielczość urządzeń: ");
  Serial.print(sensors.getResolution(), DEC);
  Serial.println();

  // Replace the falowing GUID
  uint8_t mac[WL_MAC_ADDR_LENGTH];
  WiFi.macAddress(mac);
  // Replace the falowing GUID
  char GUID[SUPLA_GUID_SIZE] = {0xDB,0x24,0x19,0x4F,0x53,0x66,xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,0x09,0x2D,0x39,0x87};
  // with GUID that you can retrieve from https://www.supla.org/arduino/get-guid



  // CHANNEL0,1,2,3...8 - DS
  SuplaDevice.addDS18B20Thermometer();  // DS na GPIO02
  SuplaDevice.addDS18B20Thermometer();  
  SuplaDevice.addDS18B20Thermometer();  
  SuplaDevice.addDS18B20Thermometer();  
  SuplaDevice.addDS18B20Thermometer();  
  SuplaDevice.addDS18B20Thermometer();  
  SuplaDevice.addDS18B20Thermometer(); 
  SuplaDevice.addDS18B20Thermometer();  //Wifi

  // CHANNEL9 - RELAY
  SuplaDevice.addRelay(5, true);       // zalacza pompa podlogowki  D1   
  // CHANNEL10-14 - RELAY  
 SuplaDevice.addRelay(13, true);       // zalacza pompa na grzejniki D7
 SuplaDevice.addRelay(12, true);  //D6
 SuplaDevice.addRelay(14, true);  //D5
 SuplaDevice.addRelay(16, true);  //D0
 SuplaDevice.addRelay(1, true);   //RX

  SuplaDevice.setName("supla_PIEC");
  SuplaDevice.begin(GUID,              // Global Unique Identifier 
                    mac,               // Ethernet MAC address
                    "192.168.1.108",      // SUPLA server address
                    xxxx,        // Location ID 
                    "xxxx");    // Location Password

  Serial.println();
  Serial.println("Uruchamianie serwera aktualizacji...");
  WiFi.mode(WIFI_STA);

  MDNS.begin(host);
  httpUpdater.setup(&httpServer, update_path, update_username, update_password);
  httpServer.begin();
  MDNS.addService("http", "tcp", 81);
  Serial.printf("HTTPUpdateServer ready! Open http://%s.local%s in your browser and login with username '%s' and password '%s'\n", host, update_path, update_username, update_password);
}

void loop() {

  SuplaDevice.iterate();
  SuplaDevice.setTemperatureCallback(&get_temperature);
  httpServer.handleClient();

}

// Supla.org ethernet layer
    int supla_arduino_tcp_read(void *buf, int count) {
        _supla_int_t size = client.available();
       
        if ( size > 0 ) {
            if ( size > count ) size = count;
            return client.read((uint8_t *)buf, size);
        };
    
        return -1;
    };
    
    int supla_arduino_tcp_write(void *buf, int count) {
        return client.write((const uint8_t *)buf, count);
    };
    
    bool supla_arduino_svr_connect(const char *server, int port) {
          return client.connect(server, 2015);
    }
    
    bool supla_arduino_svr_connected(void) {
          return client.connected();
    }
    
    void supla_arduino_svr_disconnect(void) {
         client.stop();
    }
    
    void supla_arduino_eth_setup(uint8_t mac[6], IPAddress *ip) {

        Serial.println("WiFi init");
        WiFi.begin(ssid, password);

        while (WiFi.status() != WL_CONNECTED) {
            delay(500);
            Serial.print(".");
        }

        Serial.print("\nlocalIP: ");
        Serial.println(WiFi.localIP());
        Serial.print("subnetMask: ");
        Serial.println(WiFi.subnetMask());
        Serial.print("gatewayIP: ");
        Serial.println(WiFi.gatewayIP());
    }


SuplaDeviceCallbacks supla_arduino_get_callbacks(void) {
  SuplaDeviceCallbacks cb;

  cb.tcp_read = &supla_arduino_tcp_read;
  cb.tcp_write = &supla_arduino_tcp_write;
  cb.eth_setup = &supla_arduino_eth_setup;
  cb.svr_connected = &supla_arduino_svr_connected;
  cb.svr_connect = &supla_arduino_svr_connect;
  cb.svr_disconnect = &supla_arduino_svr_disconnect;
  cb.get_temperature = &get_temperature;

  return cb;
}
Benon
Posts: 30
Joined: Tue Jan 15, 2019 8:17 am

Sun Feb 10, 2019 5:26 pm

Dzięki Cino111, zainstalowałem 2.3.0 i zaczęło wszystko działać :) Jestem programistą (bazodanowym) a raczej byłem jakieś 20 lat temu i Arduino dopiero poznaję ale radzę sobie pomalutku :)
dogu18
Posts: 53
Joined: Thu Oct 11, 2018 8:35 pm

Wed Feb 27, 2019 3:05 pm

Cześć:)

prośbę taką mam czy mógł by ktoś wrzucić pusty szkic do arduino żeby zacząć pisać swój program.

tak żeby wiedzieć co musi być a co jest zbędne. nie musi mieć żadnego GUI tylko czysty początek pod dopisanie czujników przekaźników itp...

najlepiej pod wemos d1 :)


z góry bardzo dziękuje
User avatar
shimano73
Posts: 659
Joined: Sun Feb 28, 2016 12:27 pm
Location: Orzesze

Wed Feb 27, 2019 3:34 pm

Tu jest pod mega i esp
https://github.com/SUPLA/arduino
dogu18
Posts: 53
Joined: Thu Oct 11, 2018 8:35 pm

Wed Feb 27, 2019 3:50 pm

jestem laikiem
widzę że to samo co przykłady e arduino IDE . którego użyć najlepiej żeby zaciąć pisać swój program od zera
cino111
Posts: 346
Joined: Mon May 07, 2018 8:00 pm

Wed Feb 27, 2019 4:01 pm

Masz tu gotowca dla Arduino Mega z termometrami DS18b20 i DHT22, z czujnikiem odległości (akurat dla ekogroszku w podajniku dlatego mam dodatkowo wpis, że im mniej ekogroszku czyli wieksza odległość od czujnika tym mniejsza odleglosc w aplikacji i dodatkowo przy odleglosci mniejszej niż zero ma pokazac 2m to takie zabezpieczenie jak otwieram podajnik zeby nie piszczalo). Dodatkowo fizyczne przyciski dla przekaźników i na samym dole wysleszowane linki bezpośrednie dla suplascripts dla jednego GPIO analogowego o rożnej rezystancji wejścia (mozesz to usunąć)

Code: Select all

/

#include <SPI.h>
#include <Ethernet.h>
#include <OneWire.h>
#include <DHT.h>
#include <DallasTemperature.h>
#include <SuplaDevice.h>

#define BTN_COUNT 2  // definiujemy ile ma być przycisków 

#define ONE_WIRE 24 // nr pinu dla termometru DS18B20
#define TEMPERATURE_PRECISION 10  // rozdzielczość czujnika DS 9 -12 bit
OneWire oneWire(ONE_WIRE);
DallasTemperature sensors(&oneWire);


#define DHTPIN 25 // nr pinu dla czujnika temp i wilgotności DHT22
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

//*******linki bezposrednie********
const char* host = "192.168.1.10";
const int httpsPort = 81;
String url = "/direct";
int buttonValue; //przechowuje warosc analogowa po nacisnieciu przycisku


//********czujnik odleglosci******
int Trig = 28; // Numer pinu wyzwolenia dla czujnika odległości HC-SR04
int Echo = 29; // Numer pinu odpowiedzi dla czujnika odległości HC-SR04
int Buzzer = 53; // Numer pinu do podłązenia buzera, który wlaczy sie przy pozimie mizszym niz 20cm
long EchoTime; // Czas trwania sygnału ECHO
int odleglosc;

DeviceAddress jeden = { 0x28, 0xFF, 0xEC, 0xFE, 0xC1, 0x17, 0x1, 0xF3 };       // odczytany adres 28FF2EFBC11701D3  
DeviceAddress dwa = { 0x28, 0xFF, 0xEA, 0x16, 0xC2, 0x17, 0x1, 0xDE };     //Odczytany adres 28FFEA16C21701DE 
DeviceAddress trzy = { 0x28, 0xFF, 0xBC, 0xA, 0xC2, 0x17, 0x1, 0xFD };   // odczytany adres 28FFBC0AC21701FD
DeviceAddress cztery = { 0x28, 0xFF, 0x8, 0x7E, 0xC1, 0x17, 0x2, 0xD };   // odczytany adres 28FF087EC117020D
DeviceAddress piec = { 0x28, 0xFF, 0xCD, 0xCB, 0xC1, 0x17, 0x1, 0xF };   // odczytany adres 28FFCDCBC117010F
DeviceAddress szesc = { 0x28, 0xFF, 0xA9, 0x6A, 0xC1, 0x17, 0x2, 0xC5 };   // odczytany adres 28FFA96AC11702C5
DeviceAddress siedem = { 0x28, 0xFF, 0x8, 0xBF, 0xC1, 0x17, 0x1, 0x59 };   // odczytany adres 28FF08BFC1170159

//***********button*****************//
 typedef struct {
  int pin;
  int relay_pin;
  int channel;
  int ms;
  char last_val;
  unsigned long last_time;
} _btn_t;

_btn_t btn[BTN_COUNT];

void supla_timer() {
  char v;
  unsigned long now = millis();
  
  for(int a=0;a<BTN_COUNT;a++) {
    if (btn[a].pin > 0) {
        v = digitalRead(btn[a].pin);
        if (v != btn[a].last_val && now - btn[a].last_time ) {
           btn[a].last_val = v;
           btn[a].last_time = now;
           if (v==0)
             {
                 if ( btn[a].ms > 0 ) {
                     SuplaDevice.relayOn(btn[a].channel, btn[a].ms);
                 } 
         else if (digitalRead(btn[a].relay_pin) == 0 ) {
            SuplaDevice.relayOff(btn[a].channel);
            } 
          else {
                         SuplaDevice.relayOn(btn[a].channel, 0);
            }    
                 }
             }
        }
  
    }
}



void supla_btn_init() {
  for(int a=0;a<BTN_COUNT;a++)
    if (btn[a].pin > 0) {
        pinMode(btn[a].pin, INPUT_PULLUP); 
        btn[a].last_val = digitalRead(btn[a].pin);
        btn[a].last_time = millis();
    }
}

// DS18B20 Sensor read implementation
double get_temperature(int channelNumber, double last_val) {

    double t = -275;
          switch(channelNumber)
         {

            case 0:
         sensors.requestTemperatures();
         t = sensors.getTempC(jeden);
        Serial.print("Temp 1 : ");
        Serial.println(t);
                    break;
            case 1:
         t = sensors.getTempC(dwa);
        Serial.print("Temp 2 : ");
        Serial.println(t);
                    break;
            case 2:
         t = sensors.getTempC(trzy);
        Serial.print("Temp 3 : ");
        Serial.println(t);
                    break;
            case 3:
         t = sensors.getTempC(cztery);
        Serial.print("Temp 4 : ");
        Serial.println(t);
                    break;
            case 4:
         t = sensors.getTempC(piec);
        Serial.print("Temp 5 : ");
        Serial.println(t);
                    break;
            case 5:
         t = sensors.getTempC(szesc);
        Serial.print("Temp 6 : ");
        Serial.println(t);
                    break;
            case 6:
         t = sensors.getTempC(siedem);
        Serial.print("Temp 7 : ");
        Serial.println(t);
                    break;
       
          }
         
    return t;  
}
                                 
// funkcja drukowania adresu urządzenia
void printAddress(DeviceAddress deviceAddress)
{
  for (uint8_t i = 0; i < 8; i++)
  {
    // zero pad the address if necessary
    if (deviceAddress[i] < 16) Serial.print("0");
    Serial.print(deviceAddress[i], HEX);
  }
}

// DHT22 Sensor read implementation
void get_temperature_and_humidity(int channelNumber, double *temp, double *humidity) {

    *temp = dht.readTemperature();
    *humidity = dht.readHumidity();

    if ( isnan(*temp) || isnan(*humidity) ) {
      *temp = -275;
      *humidity = -1;
    }

}




//******************czujnik odległości HC-SR04 *********************************
double get_distance(int channelNumber, double distance) {

// Ustawiamy TRIG w stan niski na 2us
digitalWrite(Trig, LOW);
delayMicroseconds(2);

// Ustawiamy TRIG w stan wysoki na 10us
digitalWrite(Trig, HIGH);
delayMicroseconds(10);

// Ustawiamy TRIG w stan niski - rozpoczynamy pomiar
digitalWrite(Trig, LOW);

// Odczytujamy czas trwania stanu wysokiego na pinie ECHO
EchoTime = pulseIn(Echo, HIGH);

// Obliczamy odległość
distance = 92-EchoTime / 58; // Odległość w metrach
distance = distance / 100;// Odległość w centymetrach
if (distance <= 0 ) {
  distance = 2;
}

if ((distance > 0) && (distance < 0.2)) { // przy jakiej odleglosci ma się właczyć buzzer
  digitalWrite(Buzzer, LOW); //wlacza buzzer przy dystansie mniejszym niz 20cm
} else {
  digitalWrite(Buzzer, HIGH); //wylacz buzzer przy dystansie większym niż 20cm
} 

Serial.println(distance); 

return distance;
}

void setup() {

  Serial.begin(9600);



  // Init DS18B20 library 
  sensors.begin();
  
  // Set temperature callback
  SuplaDevice.setTemperatureCallback(&get_temperature);
 //******Odczyt DS wraz z adresami********************
  // zlokalizuj urządzenia na szynie danych
  Serial.print("Lokalizowanie urządzeń...");
  Serial.print(" znaleziono ");
  Serial.print(sensors.getDeviceCount(), DEC);
  Serial.println(" urządzeń.");

  // zgłosić zapotrzebowanie na moc pasożytniczą
  Serial.print("Zasilanie pasożytnicze jest: ");
  if (sensors.isParasitePowerMode()) Serial.println("ON");
  else Serial.println("OFF");

 // pokaż adresy, które znaleźliśmy na szynie
  Serial.print("Adres Urządzenia 0: ");
  printAddress(jeden);
  Serial.println();

  Serial.print("Adres Urządzenia 1: ");
  printAddress(dwa);
  Serial.println();

  Serial.print("Adres Urządzenia 2: ");
  printAddress(trzy);
  Serial.println();

  Serial.print("Adres Urządzenia 3: ");
  printAddress(cztery);
  Serial.println();

  Serial.print("Adres Urządzenia 4: ");
  printAddress(piec);
  Serial.println();

  Serial.print("Adres Urządzenia 5: ");
  printAddress(szesc);
  Serial.println();

  Serial.print("Adres Urządzenia 6: ");
  printAddress(siedem);
  Serial.println();

  Serial.print("Adres Urządzenia 7: ");
 // printAddress(osiem);
  Serial.println();

  // ustaw rozdzielczość na 9 bitów na urządzeniach
  sensors.setResolution(jeden, TEMPERATURE_PRECISION);
  sensors.setResolution(dwa, TEMPERATURE_PRECISION);
  sensors.setResolution(trzy, TEMPERATURE_PRECISION);
  sensors.setResolution(cztery, TEMPERATURE_PRECISION);
  sensors.setResolution(piec, TEMPERATURE_PRECISION);
  sensors.setResolution(szesc, TEMPERATURE_PRECISION);
  sensors.setResolution(siedem, TEMPERATURE_PRECISION);
 // sensors.setResolution(osiem, TEMPERATURE_PRECISION);

  Serial.print("Rozdzielczość urządzeń: ");
  Serial.print(sensors.getResolution(), DEC);
  Serial.println();

    // Init DHT library 
  dht.begin(); 
  // Set temperature/humidity callback
  SuplaDevice.setTemperatureHumidityCallback(&get_temperature_and_humidity);

// Set Distance callback
  pinMode(Trig, OUTPUT);
  pinMode(Echo, INPUT);
  pinMode(Buzzer, OUTPUT);
  digitalWrite(Buzzer, HIGH);
  SuplaDevice.setDistanceCallback(&get_distance);




  



// button
  memset(btn, 0, sizeof(btn));
  btn[0].pin = 48; //pin pod którym masz przycisk (wewnętrzny PULLUP)
  btn[0].relay_pin = 44; //pin pod który podłączony jest przekaźnik
  btn[0].channel = 10; //numer kanału na którym jest przekaźnik
  btn[0].ms = 0;  //jak zero to ma być cały czas włączony
  btn[1].pin = 49; //pin pod którym masz przycisk (wewnętrzny PULLUP)
  btn[1].relay_pin = 45; //pin pod który podłączony jest przekaźnik
  btn[1].channel = 11; //numer kanału na którym jest przekaźnik
  btn[1].ms = 1000; //dodajemy to polecenie dla przycisku chwilowego i podajemy czas zalaczenia (np otwieranie bramy)//
  supla_btn_init();
  SuplaDevice.setTimerFuncImpl(&supla_timer);

  
  // Replace the falowing GUID
  char GUID[SUPLA_GUID_SIZE] = {0x67,0x29,0xDA,0x0E,0x1C,0xBB,0x02,0x88,0xE4,0x29,0x04,0x97,0x79,0x85,0x4A,0xB9};
  // with GUID that you can retrieve from https://www.supla.org/arduino/get-guid


  // Ethernet MAC address
  uint8_t mac[6] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05};

  // CHANNEL0,1,2,3...8 - DS
 // SuplaDevice.addDS18B20Thermometer();  
 // SuplaDevice.addDS18B20Thermometer();  
 // SuplaDevice.addDS18B20Thermometer();  
 // SuplaDevice.addDS18B20Thermometer();  
 // SuplaDevice.addDS18B20Thermometer();  
 // SuplaDevice.addDS18B20Thermometer();  
 // SuplaDevice.addDS18B20Thermometer(); 
 // SuplaDevice.addDS18B20Thermometer();  //Wif

 // SuplaDevice.addDHT22(); 

  SuplaDevice.addDistanceSensor();
    
  // CHANNEL0 - RELAY
  SuplaDevice.addRelay(44, true);           // 44 - Pin number where the relay is connected      
                                      // Call SuplaDevice.addRelay(44, true) with an extra "true" parameter 
                                      // to enable "port value inversion"
                                      // where HIGH == LOW, and LOW == HIGH   

  // CHANNEL1 - RELAY
  SuplaDevice.addRelay(45, true);           // 45 - Pin number where the relay is connected   


  // CHANNEL4 - Opening sensor (Normal Open)
 // SuplaDevice.addSensorNO(A0); // A0 - Pin number where the sensor is connected
                               // Call SuplaDevice.addSensorNO(A0, true) with an extra "true" parameter
                               // to enable the internal pull-up resistor


  // CHANNEL5 - Opening sensor (Normal Open)
 // SuplaDevice.addSensorNO(A1); // A1 - Pin number where the sensor is connected


 


  /*
   * SuplaDevice Initialization.
   * Server address, LocationID and LocationPassword are available at https://cloud.supla.org 
   * If you do not have an account, you can create it at https://cloud.supla.org/account/create
   * SUPLA and SUPLA CLOUD are free of charge
   * 
   */

  SuplaDevice.begin(GUID,              // Global Unique Identifier 
                    mac,               // Ethernet MAC address
                    "192.168.1.108",  // SUPLA server address
                    1,                 // Location ID 
                    "0000");               // Location Password




}

void loop() {
  SuplaDevice.iterate();
 // analog_switch();
}

/*

void direct_Link() {
  
   EthernetClient client;
 
  Serial.print("connecting to ");
  Serial.println(host);
  if (!client.connect(host, httpsPort)) {
    Serial.println("connection failed");
    return;
  }
  Serial.print("requesting URL: ");
  Serial.println(url);
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" +
               "User-Agent: Cino111\r\n" +
               "Connection: close\r\n\r\n");

   String line = client.readStringUntil('\r');
      if (line == "HTTP/1.1 204 No Content"){
        Serial.println("Wykonano scene");
       // error = 0;
       }
}
        
//https://forum.supla.org/viewtopic.php?f=10&t=4173
 void analog_switch(){
  
  buttonValue = analogRead(A0); //Read analog value from A0 pin
  delay (1000);
  Serial.println(buttonValue);
    
  //For no button:
  if (buttonValue<=50){
  delay (100);
  return;
  }
  //For 1st button:
  else if (buttonValue>=113 && buttonValue<=153){
    Serial.println("swiatlo ogrod ");
     url = "/api/scenes/execute/e7190e0d-7155-48dcc7b";
   //  token   = "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhRmYzEtODQ0OS05MjUzNmZiZWVhZDUifSwiaXNzIjoiaHR0cHM6XC9cL3N1cGxhLmZyYWN6LmNvbSIsImlhdCI6MTU0ODgzNzA1OCwibmJmIjoxNTQ4ODM3MDU4LCJleHAiOjE3MDY1MTcwNTh9.-VthDJPdPHWRnSjOONKT1uUtaF_X6CEN1zNFVrZN_IA";
    direct_Link() ;
   return;
  }
  //For 2nd button:
  else if (buttonValue>=256 && buttonValue<=296){
    Serial.println("read: 2 ");
     url = "/api/scenes/execute/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
   //  token   = "Authorization: Bearer XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
    direct_Link() ;
    return;
  }
  //For 3rd button:
  else if (buttonValue>=389  && buttonValue<=429){
    Serial.println("ogrod: 3 ");
    url = "/api/scenes/public/4a438cd3-e123-4ebe86f";
  //   token   = "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzOS05MjUzNmZiZWVhZDUifSwiaXNzIjoiaHR0cHM6XC9cL3N1cGxhLmZyYWN6LmNvbSIsImlhdCI6MTU0ODgzNzA1OCwibmJmIjoxNTQ4ODM3MDU4LCJleHAiOjE3MDY1MTcwNTh9.-VthDJPdPHWRnSjOONKT1uUtaF_X6CEN1zNFVrZN_IA";
   direct_Link() ;
    return;
  }
  //For 4th button:
  else if (buttonValue>=525  && buttonValue<=565){
    Serial.println("read: 4 ");
     url = "/api/scenes/execute/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
  //   token   = "Authorization: Bearer XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
    direct_Link() ;
    return;
  }  
  //For 5rd button:
  else if (buttonValue>=654  && buttonValue<=694){
    Serial.println("read: 5 ");
     url = "/api/scenes/execute/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
   //  token   = "Authorization: Bearer XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
    direct_Link() ;
    return;
  }
  //For 6th button:
  else if (buttonValue>=796  && buttonValue<=836){
    Serial.println("read: 6 ");
     url = "/api/scenes/execute/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
   //  token   = "Authorization: Bearer XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
    direct_Link() ;
    return;
  }
  //For 7rd button:
  else if (buttonValue>=930  && buttonValue<=970){
    Serial.println("read: 7 ");
     url = "/api/scenes/execute/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
   //  token   = "Authorization: Bearer XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
    direct_Link() ;
    return;
  }
  //For 8th button:
  else if (buttonValue>=1000 ){
    Serial.println("read: 8 ");
    url = "/api/scenes/execute/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
   //  token   = "Authorization: Bearer XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
    direct_Link() ;
    return;
  } 
}
*/
Tu masz pod Wemosa z aktualizacją online DHT22, przekaźnikiem i DS pokazującym moc WIfi

Code: Select all

#include <ESP8266WiFi.h>
#define SUPLADEVICE_CPP
#include <SuplaDevice.h>
#include <ESP8266WebServer.h>
#include <DNSServer.h>
#include <ESP8266mDNS.h>
#include <ESP8266HTTPUpdateServer.h>
extern "C" {
#include "user_interface.h"
}
// Include the libraries we need


#include <DHT.h>
#define DHTPIN 2
#define DHTTYPE DHT22
 
// Setup a DHT instance
DHT dht(DHTPIN, DHTTYPE);
#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE 1
#define TEMPERATURE_PRECISION 10  // rozdzielczość czujnika DS 9 -12 bit

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);



 


// Setup Supla connection
const char* ssid     = "Asus";
const char* password = "xxxxxx";


WiFiClient client;
const char* host = "supla";
const char* update_path = "/supla";
const char* update_username = "admin";
const char* update_password = "supla";

ESP8266WebServer httpServer(81);
ESP8266HTTPUpdateServer httpUpdater;

// Obsługa czujnika DHT22 lub BME280 itp
void get_temperature_and_humidity(int channelNumber, double *temp, double *humidity) {

    *temp = dht.readTemperature();
    *humidity = dht.readHumidity();

    if ( isnan(*temp) || isnan(*humidity) ) {
      *temp = -275;
      *humidity = -1;
    }
}


// DS18B20 Sensor read implementation
double get_temperature(int channelNumber, double last_val) {

    double t = -275;
          switch(channelNumber)
         {

            case 1:
         sensors.requestTemperatures();
         t = sensors.getTempCByIndex(0);
        Serial.println(t);
                    break;
            case 2:
         sensors.requestTemperatures();
         t = sensors.getTempCByIndex(0);
        Serial.println(t);
                    break;
            case 3:
         t = WiFi.RSSI();
        Serial.println(t);
                    break;
     
          }
         
    return t;  
}




void setup() {
  Serial.begin(115200);
  delay(10);

  wifi_station_set_hostname("Supla-Sypialnia");  //nazwa w sieci lokalnej
  WiFi.softAPdisconnect(true); // wyłączenie rozgłaszania sieci ESP

  // Inicjalizacja DS18B20
  sensors.begin();
  SuplaDevice.setTemperatureCallback(&get_temperature);


  // Init DHT library 
  dht.begin(); 
  // Set temperature/humidity callback
  SuplaDevice.setTemperatureHumidityCallback(&get_temperature_and_humidity);
  
  // Replace the falowing GUID
  uint8_t mac[WL_MAC_ADDR_LENGTH];
  WiFi.macAddress(mac);
  char GUID[SUPLA_GUID_SIZE] = {0xC1,0x1B,0x91,0x46,0x51,0xB0,0x7B,0xC0,0x82,0xF0,0x6E,0x6A,0x2E,0x70,0xC2,0x8C};
  // with GUID that you can retrieve from https://www.supla.org/arduino/get-guid



 // CHANNEL0 - DHT22
  SuplaDevice.addDHT22();                // DHT22 na GPIO02 (D4) 
  // CHANNEL1,2 DS
  SuplaDevice.addDS18B20Thermometer(); 
  SuplaDevice.addDS18B20Thermometer();// DS na GPIO14 (D5)
  SuplaDevice.addDS18B20Thermometer();  //wifi
  //CHANNEL3 - RELAY                 
  SuplaDevice.addRelay(5); 


  
  


  SuplaDevice.setName("Sypialnia");
  SuplaDevice.begin(GUID,              // Global Unique Identifier 
                    mac,               // Ethernet MAC address
                    "192.168.1.10",  // SUPLA server address
                    1,                 // Location ID 
                    "0000");               // Location Password

  Serial.println();
  Serial.println("Uruchamianie serwera aktualizacji...");
  WiFi.mode(WIFI_STA);

  MDNS.begin(host);
  httpUpdater.setup(&httpServer, update_path, update_username, update_password);
  httpServer.begin();
  MDNS.addService("http", "tcp", 81);
  Serial.printf("HTTPUpdateServer ready! Open http://%s.local%s in your browser and login with username '%s' and password '%s'\n", host, update_path, update_username, update_password);
}

void loop() {

  SuplaDevice.iterate();
  SuplaDevice.setTemperatureCallback(&get_temperature);
  SuplaDevice.setTemperatureHumidityCallback(&get_temperature_and_humidity);
  httpServer.handleClient();

}

// Supla.org ethernet layer
    int supla_arduino_tcp_read(void *buf, int count) {
        _supla_int_t size = client.available();
       
        if ( size > 0 ) {
            if ( size > count ) size = count;
            return client.read((uint8_t *)buf, size);
        };
    
        return -1;
    };
    
    int supla_arduino_tcp_write(void *buf, int count) {
        return client.write((const uint8_t *)buf, count);
    };
    
    bool supla_arduino_svr_connect(const char *server, int port) {
          return client.connect(server, 2015);
    }
    
    bool supla_arduino_svr_connected(void) {
          return client.connected();
    }
    
    void supla_arduino_svr_disconnect(void) {
         client.stop();
    }
    
    void supla_arduino_eth_setup(uint8_t mac[6], IPAddress *ip) {

        Serial.println("WiFi init");
        WiFi.begin(ssid, password);

        while (WiFi.status() != WL_CONNECTED) {
            delay(500);
            Serial.print(".");
        }

        Serial.print("\nlocalIP: ");
        Serial.println(WiFi.localIP());
        Serial.print("subnetMask: ");
        Serial.println(WiFi.subnetMask());
        Serial.print("gatewayIP: ");
        Serial.println(WiFi.gatewayIP());
    }


SuplaDeviceCallbacks supla_arduino_get_callbacks(void) {
  SuplaDeviceCallbacks cb;

  cb.tcp_read = &supla_arduino_tcp_read;
  cb.tcp_write = &supla_arduino_tcp_write;
  cb.eth_setup = &supla_arduino_eth_setup;
  cb.svr_connected = &supla_arduino_svr_connected;
  cb.svr_connect = &supla_arduino_svr_connect;
  cb.svr_disconnect = &supla_arduino_svr_disconnect;
  cb.get_temperature = &get_temperature;
  cb.get_temperature_and_humidity = &get_temperature_and_humidity;
  return cb;
}
dogu18
Posts: 53
Joined: Thu Oct 11, 2018 8:35 pm

Fri Mar 08, 2019 11:44 pm

Cześć

próbuje odpalić czujnik BME280
wykorzystuje kod znaleziony na forum i staram się go modyfikować żeby działo.
na razie sie skompilowało ale nie zgłasza mi się na Cloud...
gdzie popełniłem błąd w kodzie??? jak można prosić o taką pomoc

pozdrawiam Grzegorz

Code: Select all

//  **************************************************************************************************************
//  * Kompilowane na Arduino 1.8.5 by@wojtas567                                                                               *
//  * Po odczytaniu adresów czujników należy je wpisać do tablicy wg poniższego wzoru                            *
//  * DeviceAddress jeden = { 0x28, 0xFF, 0xE8, 0x00, 0xB6, 0x16, 0x03, 0x65 };                                  *      
//  * DeviceAddress dwa = { 0x28, 0xFF, 0x54, 0x6F, 0xB3, 0x16, 0x05, 0xE9 };                                    *
//  * ...                                                                                                        *
//  *                                                                                                            *
//  * a na stępnie usunąć wiersze:                                                                               *
//  *        *    DeviceAddress jeden, dwa, trzy, cztery, piec, szesc, siedem, osiem;                            *
//  *                                                                                                            *
//  *        *    if (!sensors.getAddress(jeden, 0)) Serial.println("Nie można znaleźć adresu urządzenia 0");    *
//  *        *    if (!sensors.getAddress(dwa, 1)) Serial.println("Nie można znaleźć adresu urządzenia 1");      *
//  *        *    if (!sensors.getAddress(trzy, 2)) Serial.println("Nie można znaleźć adresu urządzenia 2");     *
//  *        *    if (!sensors.getAddress(cztery, 3)) Serial.println("Nie można znaleźć adresu urządzenia 3");   *
//  *        *    if (!sensors.getAddress(piec, 4)) Serial.println("Nie można znaleźć adresu urządzenia 4");     *
//  *        *    if (!sensors.getAddress(szesc, 5)) Serial.println("Nie można znaleźć adresu urządzenia 5");    *
//  *        *    if (!sensors.getAddress(siedem, 6)) Serial.println("Nie można znaleźć adresu urządzenia 6");   *
//  *        *    if (!sensors.getAddress(osiem, 7)) Serial.println("Nie można znaleźć adresu urządzenia 6");    *
//  *                                                                                                            *
//  **************************************************************************************************************


#include <ESP8266WiFi.h>
#define SUPLADEVICE_CPP
#include <SuplaDevice.h>

#include <ESP8266WebServer.h>
#include <DNSServer.h>
#include <ESP8266mDNS.h>
#include <ESP8266HTTPUpdateServer.h>
extern "C" {
#include "user_interface.h"
}
// Include the libraries we need
#include <OneWire.h>
#include <DallasTemperature.h>

//inicjalizacja bme280
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

#define BME_SCK 5
#define BME_MISO 4


#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BME280 bme; // I2C

// Data wire is plugged into port 2 on the Arduino
//#define ONE_WIRE 16
//#define TEMPERATURE_PRECISION 10  // rozdzielczość czujnika DS 9 -12 bit

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

// tablica do przechowywania adresów urządzeń
//DeviceAddress jeden, dwa, trzy, cztery, piec, szesc, siedem, osiem;

// lub tu już wprowadzone
/*

DeviceAddress jeden = { 0x28, 0xFF, 0xEC, 0xFE, 0xC1, 0x17, 0x1, 0xF3 };       // odczytany adres 28FF2EFBC11701D3  
DeviceAddress dwa = { 0x28, 0xFF, 0xEA, 0x16, 0xC2, 0x17, 0x1, 0xDE };     //Odczytany adres 28FFEA16C21701DE 
DeviceAddress trzy = { 0x28, 0xFF, 0xBC, 0xA, 0xC2, 0x17, 0x1, 0xFD };   // odczytany adres 28FFBC0AC21701FD
DeviceAddress cztery = { 0x28, 0xFF, 0x8, 0x7E, 0xC1, 0x17, 0x2, 0xD };   // odczytany adres 28FF087EC117020D
DeviceAddress piec = { 0x28, 0xFF, 0xCD, 0xCB, 0xC1, 0x17, 0x1, 0xF };   // odczytany adres 28FFCDCBC117010F
DeviceAddress szesc = { 0x28, 0xFF, 0xA9, 0x6A, 0xC1, 0x17, 0x2, 0xC5 };   // odczytany adres 28FFA96AC11702C5


*/

// Setup Supla connection
const char* ssid     = "xxx";
const char* password = "xxx";

WiFiClient client;
const char* host = "supla";
const char* update_path = "/supla";
const char* update_username = "admin";
const char* update_password = "supla";

ESP8266WebServer httpServer(81);
ESP8266HTTPUpdateServer httpUpdater;

// Odczyt z czujnika BME280 temperatury i wilgotności
void get_temperature_and_humidity (int channelNumber, double *temp, double *humidity) {

  *temp = bme.readTemperature();   
  *humidity = bme.readHumidity();
}


// Odczyt z czujnika BME280 ciśnienie i siły sygnału Wifi z ESP
double get_pressure(int channelNumber, double last_val) {

  double t = -275;
  switch (channelNumber)
  {

         case 0:
      t = (bme.readPressure() / 100.0F); 
      Serial.print("BME Ciśnienie: ");        
      Serial.println(t);
    //  last_pressure = t; //GUI
      break;
 /*           case 1:
         t = sensors.getTempC(dwa);
        Serial.print("Temp 2 : ");
        Serial.println(t);
                    break;
            case 2:
         t = sensors.getTempC(trzy);
        Serial.print("Temp 3 : ");
        Serial.println(t);
                    break;
            case 3:
         t = sensors.getTempC(cztery);
        Serial.print("Temp 4 : ");
        Serial.println(t);
                    break;
            case 4:
         t = sensors.getTempC(piec);
        Serial.print("Temp 5 : ");
        Serial.println(t);
                    break;
            case 5:
         t = sensors.getTempC(szesc);
        Serial.print("Temp 6 : ");
        Serial.println(t);
                    break;
            case 6:
         t = sensors.getTempC(siedem);
        Serial.print("Temp 7 : ");
        Serial.println(t);
                    break;
            case 7:
         t = WiFi.RSSI();
        Serial.print("Temp 8 : ");
        Serial.println(t);
        Serial.println("***********GOTOWE*************");
                    break;
                    */
          }
         
    return t;  
}
                                 
// funkcja drukowania adresu urządzenia
void printAddress(DeviceAddress deviceAddress)
{
  for (uint8_t i = 0; i < 8; i++)
  {
    // zero pad the address if necessary
    if (deviceAddress[i] < 16) Serial.print("0");
    Serial.print(deviceAddress[i], HEX);
  }
}

void setup() {
  Serial.begin(115200);
  delay(10);

  wifi_station_set_hostname("Supla-TEST");  //nazwa w sieci lokalnej
  WiFi.softAPdisconnect(true); // wyłączenie rozgłaszania sieci ESP

  // Inicjalizacja DS18B20
  sensors.begin();
  SuplaDevice.setTemperatureCallback(&get_pressure);

/*
//******Odczyt DS wraz z adresami********************
  // zlokalizuj urządzenia na szynie danych
  Serial.print("Lokalizowanie urządzeń...");
  Serial.print(" znaleziono ");
  Serial.print(sensors.getDeviceCount(), DEC);
  Serial.println(" urządzeń.");

  // zgłosić zapotrzebowanie na moc pasożytniczą
  Serial.print("Zasilanie pasożytnicze jest: ");
  if (sensors.isParasitePowerMode()) Serial.println("ON");
  else Serial.println("OFF");
  

  if (!sensors.getAddress(jeden, 0)) Serial.println("Nie można znaleźć adresu urządzenia 0");
  if (!sensors.getAddress(dwa, 1)) Serial.println("Nie można znaleźć adresu urządzenia 1");
  if (!sensors.getAddress(trzy, 2)) Serial.println("Nie można znaleźć adresu urządzenia 2");
  if (!sensors.getAddress(cztery, 3)) Serial.println("Nie można znaleźć adresu urządzenia 3");
  if (!sensors.getAddress(piec, 4)) Serial.println("Nie można znaleźć adresu urządzenia 4");
  if (!sensors.getAddress(szesc, 5)) Serial.println("Nie można znaleźć adresu urządzenia 5");
  if (!sensors.getAddress(siedem, 6)) Serial.println("Nie można znaleźć adresu urządzenia 6");
  if (!sensors.getAddress(osiem, 7)) Serial.println("Nie można znaleźć adresu urządzenia 6");
*/
/*
  // pokaż adresy, które znaleźliśmy na szynie
  Serial.print("Adres Urządzenia 0: ");
  printAddress(jeden);
  Serial.println();

  Serial.print("Adres Urządzenia 1: ");
  printAddress(dwa);
  Serial.println();

  Serial.print("Adres Urządzenia 2: ");
  printAddress(trzy);
  Serial.println();

  Serial.print("Adres Urządzenia 3: ");
  printAddress(cztery);
  Serial.println();

  Serial.print("Adres Urządzenia 4: ");
  printAddress(piec);
  Serial.println();

  Serial.print("Adres Urządzenia 5: ");
  printAddress(szesc);
  Serial.println();

  Serial.print("Adres Urządzenia 6: ");
  printAddress(siedem);
  Serial.println();

  Serial.print("Adres Urządzenia 7: ");
 // printAddress(osiem);
  Serial.println();

  // ustaw rozdzielczość na 9 bitów na urządzeniach
  sensors.setResolution(jeden, TEMPERATURE_PRECISION);
  sensors.setResolution(dwa, TEMPERATURE_PRECISION);
  sensors.setResolution(trzy, TEMPERATURE_PRECISION);
  sensors.setResolution(cztery, TEMPERATURE_PRECISION);
  sensors.setResolution(piec, TEMPERATURE_PRECISION);
  sensors.setResolution(szesc, TEMPERATURE_PRECISION);
  sensors.setResolution(siedem, TEMPERATURE_PRECISION);
 // sensors.setResolution(osiem, TEMPERATURE_PRECISION);

  Serial.print("Rozdzielczość urządzeń: ");
  Serial.print(sensors.getResolution(), DEC);
  Serial.println();

  */

  // Replace the falowing GUID
  uint8_t mac[WL_MAC_ADDR_LENGTH];
  WiFi.macAddress(mac);
  // Replace the falowing GUID
  char GUID[SUPLA_GUID_SIZE] = {0xA7,0xC6,0x05,0xDB,0xEC,0xA3,0xE1,0x33,0xDB,0xFC,0x8D,0x92,0x06,0x78,0xB3,0x02};
  // with GUID that you can retrieve from https://www.supla.org/arduino/get-guid



  // CHANNEL0,1,2,3...8 - DS
  SuplaDevice.addPressureSensor();    // channel 0 pressure from BME280 (kPa)
  SuplaDevice.addDHT22();             // channel 2 temperature & humidity from BME280 
  //SuplaDevice.addDS18B20Thermometer();  
  //SuplaDevice.addDS18B20Thermometer();  
  //SuplaDevice.addDS18B20Thermometer();  
  //SuplaDevice.addDS18B20Thermometer();  
  //SuplaDevice.addDS18B20Thermometer(); 
  //SuplaDevice.addDS18B20Thermometer();  //Wifi
/*
  // CHANNEL9 - RELAY
  SuplaDevice.addRelay(5, true);       // zalacza pompa podlogowki  D1   
  // CHANNEL10-14 - RELAY  
 SuplaDevice.addRelay(13, true);       // zalacza pompa na grzejniki D7
 SuplaDevice.addRelay(12, true);  //D6
 SuplaDevice.addRelay(14, true);  //D5
 SuplaDevice.addRelay(16, true);  //D0
 SuplaDevice.addRelay(1, true);   //RX
 */
 

  SuplaDevice.setName("supla_TEST");
  SuplaDevice.begin(GUID,              // Global Unique Identifier 
                    mac,               // Ethernet MAC address
                    "xxx.supla.org",      // SUPLA server address
                    xxxx,        // Location ID 
                    "xxxx");    // Location Password

  Serial.println();
  Serial.println("Uruchamianie serwera aktualizacji...");
  WiFi.mode(WIFI_STA);

  MDNS.begin(host);
  httpUpdater.setup(&httpServer, update_path, update_username, update_password);
  httpServer.begin();
  MDNS.addService("http", "tcp", 81);
  Serial.printf("HTTPUpdateServer ready! Open http://%s.local%s in your browser and login with username '%s' and password '%s'\n", host, update_path, update_username, update_password);
}

void loop() {

  SuplaDevice.iterate();
  SuplaDevice.setTemperatureCallback(&get_pressure);
  httpServer.handleClient();

}

// Supla.org ethernet layer
    int supla_arduino_tcp_read(void *buf, int count) {
        _supla_int_t size = client.available();
       
        if ( size > 0 ) {
            if ( size > count ) size = count;
            return client.read((uint8_t *)buf, size);
        };
    
        return -1;
    };
    
    int supla_arduino_tcp_write(void *buf, int count) {
        return client.write((const uint8_t *)buf, count);
    };
    
    bool supla_arduino_svr_connect(const char *server, int port) {
          return client.connect(server, 2015);
    }
    
    bool supla_arduino_svr_connected(void) {
          return client.connected();
    }
    
    void supla_arduino_svr_disconnect(void) {
         client.stop();
    }
    
    void supla_arduino_eth_setup(uint8_t mac[6], IPAddress *ip) {

        Serial.println("WiFi init");
        WiFi.begin(ssid, password);

        while (WiFi.status() != WL_CONNECTED) {
            delay(500);
            Serial.print(".");
        }

        Serial.print("\nlocalIP: ");
        Serial.println(WiFi.localIP());
        Serial.print("subnetMask: ");
        Serial.println(WiFi.subnetMask());
        Serial.print("gatewayIP: ");
        Serial.println(WiFi.gatewayIP());
    }


SuplaDeviceCallbacks supla_arduino_get_callbacks(void) {
  SuplaDeviceCallbacks cb;

  cb.tcp_read = &supla_arduino_tcp_read;
  cb.tcp_write = &supla_arduino_tcp_write;
  cb.eth_setup = &supla_arduino_eth_setup;
  cb.svr_connected = &supla_arduino_svr_connected;
  cb.svr_connect = &supla_arduino_svr_connect;
  cb.svr_disconnect = &supla_arduino_svr_disconnect;
  cb.get_temperature = &get_pressure;

  return cb;
}
Last edited by dogu18 on Sat Mar 09, 2019 9:47 am, edited 1 time in total.
Post Reply