[PORADNIK] Arduino IDE

Benon
Posts: 13
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: 277
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: 13
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: 277
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: 13
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 :)
Post Reply