My problem is that on the input of the WiFiConnectionHandler constructor, the readFile(), which works fine elsewhere, does not read the file.
I dont have any error messages, just a failed connection to "" (blank string network)
Here is my code, sorry for the bad formatting and comments
/*
Editor: Kertesz Domokos (kerteszdomokos@gmail.com)
Version: v1.5-beta
*/
//Header fileok
#include <Arduino.h>
#include "a_home.h"
#include "wifi-icos.h"
// #include "thingProperties.h"
#include "website.h"
#include <GxEPD2_BW.h> // including both doesn't use more code or ram
#include <GxEPD2_3C.h> // including both doesn't use more code or ram
#include <pgmspace.h>
#include <Adafruit_GFX.h>
#include <Fonts/FreeSansBold12pt7b.h>
#include <Fonts/Roboto_12.h>
#include <Fonts/Roboto_Bold_14.h>
#include <Fonts/Roboto_Bold_39.h>
#include <Fonts/FreeSans9pt7b.h>
#include <Fonts/FreeSans12pt7b.h>
#include <Fonts/FreeSans18pt7b.h>
#include <Fonts/FreeSans24pt7b.h>
#include <Fonts/FreeSansBold9pt7b.h>
#include <DHT.h>
#include <TimeLib.h>
#include <LittleFS.h>
#include <ESP8266WiFi.h>
#include <Hash.h>
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <EEPROM.h>
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <Hash.h>
#include <FS.h>
#include <ArduinoIoTCloud.h>
#include <Arduino_ConnectionHandler.h>
#define AnalogInput A0
#define DHTPIN 3 // RX PIN
//Kijelző beállításai
#define GxEPD2_DISPLAY_CLASS GxEPD2_BW
#define GxEPD2_DRIVER_CLASS GxEPD2_290_T94_V2 // ez a kijelző
#define MAX_DISPLAY_BUFFER_SIZE (81920ul-34000ul-5000ul) // ~34000 base use, change 5000 to your application use
#define MAX_HEIGHT(EPD) (EPD::HEIGHT <= MAX_DISPLAY_BUFFER_SIZE / (EPD::WIDTH / 8) ? EPD::HEIGHT : MAX_DISPLAY_BUFFER_SIZE / (EPD::WIDTH / 8))
#define DHTTYPE DHT22
//Beállíthato változók
int InterruptPin = 4;
int ReadValue = 0;
int VolumeOld = -1;
int Volume = 0;
char Result = (' ');
int lightPin = 1; //TX PIN //fenyero a fény ereje
int humPin = 12; //D6/
int fanPin = 2; //D4
/**
A napi okosságokat tartalmazó lista
*/
String didu[11][2] =
{ {"Mushrooms are genetically", "closer to humans than plants."},
{"Fungi are the largest", "life forms on earth"},
{"Fungi allow trees to", "talk to each other"},
{"Mushrooms are the fruit", "of a fungus"},
{"Mushrooms can create", "airflow to disperse spores"},
{"There’s a mushroom that", "devours itself when picked"},
{"Mushrooms produce vitamin D", " "},
{"Mushrooms create fairy rings", " "},
{"You can use mushrooms", "as a natural pesticide"},
{"Lightning boosts", "mushroom growth"},
{"Lightning boosts", "mushroom growth"}
};
/**
A napi érdekességek két sorának kezdő koordinátái
*/
int16_t cors[11][2] = {
{30, 20},
{60, 74},
{65, 79},
{45, 100},
{55, 39},
{50, 40},
{15, 0},
{20, 0},
{35, 50},
{68, 65},
{68, 65}
};
// DHT dht(DHTPIN, DHTTYPE);
GxEPD2_DISPLAY_CLASS <GxEPD2_DRIVER_CLASS, MAX_HEIGHT(GxEPD2_DRIVER_CLASS)>
display(GxEPD2_DRIVER_CLASS(/**CS=D8*/ 0, /**DC=D3*/ 15, /**RST=D4*/ 5, /**BUSY=D2*/ 16));
//DHT beállítása
//Variables
int daynum = 1; //a termesztés jelenlegi napja
unsigned long unixtime;// a jelenlegi unix formátumú idő tárolására szolgáló változó
long millisToTime = 0;
long onlinecheckTime = 0;
long legcsereTime = 0;
long legcsereTimeOn = 0;
bool legcsereOn = 0;
int loadlineState = 0; //A folyamat töltővonalának állpota, nem csak naponta növekszik
long ledStateTime;
long paraTime;
int lastVolume;
long voltime;
int growpoint = 0;
long reftime;
bool online;
bool lastOnline;
bool ledState = false;
float para;
float homerseklet;
long paraAutoTime;
long paraAutoTimeOn;
long paraOffTime;
bool normal=0;
bool firstStep=1;
bool secondStep=0;
bool apon=0;
bool beginned=0;
String lastSSID;
String eeprssid;
String eeprpass;
//thingProperties
const char DEVICE_LOGIN_NAME[] = "2a93a86c-b9eb-4ae0-aed2-cddf35c12f59";
const char DEVICE_KEY[] = "KEPPUTOYOFUK9Q6WD1NX"; // Secret device password
String SSIDiot;
String PASS;
String growStartTime;
String messages;
CloudTemperatureSensor tempwifi;
int celPara=80;
int fanSpeed=255;
int fenyero;
int lightOffTime=22;
int lightOnTime=10;
int paraCiklus=10000;
int paraPeriod=100;
int timezone;
CloudRelativeHumidity humwifi;
bool fanStatus;
bool humSatus;
bool paraSzenzorOff=0;
bool switchh=0;
void ICACHE_RAM_ATTR read_encoder(); //Hogy ne fagyjon be az encoder
AsyncWebServer server(80);
String readFile(const char * path) {
if(beginned==0){
LittleFS.begin();
beginned=1;
}
Serial.printf("Reading file: %s\n", path);
File file = LittleFS.open(path, "r");
if (!file) {
Serial.println("Failed to open file for reading");
return "error";
}
String cont;
Serial.print("Read from file: ");
cont=file.readStringUntil('\n');
// while (file.available()) {
// cont+=String((char)file.read());
// Serial.write(file.read());
// }
delay(10);
file.close();
return cont;
}
void writeFile(const char * path, String message) {
Serial.printf("Writing file: %s\n", path);
File file = LittleFS.open(path, "w");
if (!file) {
Serial.println("Failed to open file for writing");
return;
}
if (file.print(message+"\n")) {
Serial.println("File written "+message);
} else {
Serial.println("Write failed "+message);
}
file.flush();
delay(10);
file.close();
}
WiFiConnectionHandler ArduinoIoTPreferredConnection(readFile("/ssid.txt").c_str(), readFile("/pass.txt").c_str()); //Here is the problem
void setup() {
pinMode(lightPin, OUTPUT);
pinMode(fanPin, OUTPUT);
pinMode(humPin, OUTPUT);
pinMode(InterruptPin, INPUT);
Serial.begin(115200);
Serial.println("Setup begin...");
EEPROM.begin(512);
// WiFi.softAP(ssid);
// IPAddress IP = WiFi.softAPIP();
Serial.println("filesystem begin...");
if(!beginned){
bool suc = LittleFS.begin();
beginned=1;
Serial.println("filesystem inicialize: "+String(suc));
}
Serial.println("ssid and pass config...");
SSIDiot=readFile("/ssid.txt");
PASS=readFile("/pass.txt");
Serial.println("wifidatas updatet from files...");
//Példány beállítások
display.setRotation(1); //képernyő tájolása
display.init();
// dht.begin();
Serial.println("display and dhtz config success...");
Serial.println("SSID,PASS: "+SSIDiot+PASS);
WiFi.mode(WIFI_STA);
iotconfig();
//Induláskor meghívandó függvények
// reftime = ArduinoCloud.getInternalTime();//iotconfig után
// eeprRead();//EEPROM adatok betöltése
// onlineCheck();// eszköz csatlakozik-e az internethez
// updateScreen();//Képernyő frissítése
attachInterrupt (digitalPinToInterrupt(InterruptPin), read_encoder, RISING);
Serial.println("setup ended.");
}
void loop() {
if(normal==0){
if(millis()<30000 &&SSIDiot!=""){
firstStep=0;
}else{
secondStep=1;
firstStep=1;
}
if(firstStep==0){
Serial.print("Check... ");
switch(ArduinoCloud.getConnection()->getStatus()){
case NetworkConnectionState::INIT: Serial.println("INIT");break;
case NetworkConnectionState::CONNECTING: Serial.println("CONNECTING");break;
case NetworkConnectionState::CONNECTED: Serial.println("CONNECTED");break;
case NetworkConnectionState::DISCONNECTING: Serial.println("DISCONNECTING");break;
case NetworkConnectionState::DISCONNECTED: Serial.println("DISCONNECTED"); break;
case NetworkConnectionState::ERROR: Serial.println("ERROR"); break;
default: Serial.println("dontknow"); break;
}
if(ArduinoCloud.getConnection()->getStatus()==NetworkConnectionState::CONNECTED ){
normal=1;
}
ArduinoCloud.update();
}
if(secondStep==1){
if(ArduinoCloud.getConnection()->getStatus()!=NetworkConnectionState::CONNECTED){
lastSSID = SSIDiot;
SSIDiot = readFile("/ssid.txt");
if(apon==0){
ArduinoCloud.getConnection()->disconnect();
firstStep=1;
Serial.println("Make AP");
configAP();
apon=1;
}
}
}
if(apon==1){
if(eeprssid!=lastSSID){
WiFi.disconnect();
ESP.restart();
}
}
}
//
//normal futás, amennyiben nem szükséges a konfiguráció
if(normal==1){
if (millis() - millisToTime >= 1728000 && online == 0) { //EEPROM írása kb. fél óránként (hiba nélküli termesztés során 100 írás történik)
eeprWrite();
}
if (millis() - onlinecheckTime >= 1000) {// Másodpercenkénti képernyő, és pontos idő frissítés
onlineCheck();
updateScreen();
calcLine();
dayCalc();
onlinecheckTime = millis();
messages=String(humSatus);
}
if (millis() - ledStateTime >= 10000) {//5 másodpercenkénti LED check, amennyiben szükséges beállít
ledAuto();
ledStateTime = millis();
sensorRead();
}
if (lastVolume != Volume) {//Encoder változásának érzékelése
encoder();
}
lastVolume = Volume;
if (millis() - legcsereTime >= 1800000) { //Fél óránkénti légcsere
legcsereOn = 1;
}
//online értékek frissítése
legcsere();
if(paraSzenzorOff==0){paraCheck();}else{paraAuto();}
ArduinoCloud.update();
if(humSatus==1){
analogWrite(12,255);
}else{
analogWrite(12,0);
}
}
}
void paraAuto(){
if (millis()-paraAutoTime > paraPeriod) {
paraAutoTime = millis();
paraAutoTimeOn = millis();
analogWrite(humPin, 255);
}
if (millis() - paraAutoTime > paraCiklus) {
analogWrite(humPin, 0);
}
}
/**
Aszükséges változókat a Flash memóriába írja
*/
void eeprWrite() {
EEPROM_writelong(0, now());
EEPROM_writelong(1, loadlineState);
EEPROM_writelong(2, daynum);
millisToTime = millis();
}
void eeprRead() {
setTime(EEPROM_readlong(0));
loadlineState = EEPROM_readlong(1);
daynum = EEPROM_readlong(2);
growStartTime = String(EEPROM_readlong(3));
}
/**
Amennyiben a rotary encodert forgatjuk, a LED fényerő változik, ennek állításáért felelős függvény
*/
void encoder() {
voltime = millis();
while (millis() - voltime < 5000) {
show_encoder();
if (Volume > 99) {
Volume = 100;
} if (Volume < 1) {
Volume = 0;
}
analogWrite(lightPin, int(Volume * 2.55));
changeLightScreen();
if (lastVolume != Volume) {
voltime = millis();
}
lastVolume = Volume;
}
Volume = 0;
onlineCheck();
updateScreen();
}
/**
A világítás állítására szolgáló függvény, meghíváskor ellenőrzi, hogy a lokális idő szerint
szükséges-e a lámpa állapotának változtatása
*/
void ledAuto() {
if(online=1){
int loctime = hour() + timezone;
if (loctime >= lightOnTime && loctime <= lightOffTime) {
digitalWrite(lightPin, 1);
switchh=1;
fenyero=255;
}
else {
digitalWrite(lightPin, 0);
switchh=0;
fenyero=0;
}
}else{
digitalWrite(lightPin, 1);
switchh=1;
fenyero=255;
}
}
/**
A termesztés állpotát mutató változó
*/
void calcLine() { //10nap=864000sec egy pixel szélesedés:4547, max 190
long secs = unixtime - growStartTime.toInt();
loadlineState = int(secs / 5000);
}
/**
Meghíváskor ellenőrzi a páratartalmat, és ha alacsony fél percig párásít
*/
void paraCheck() {
if (humwifi <= celPara) {
analogWrite(humPin, 255);
}else{
analogWrite(humPin, 0);
}
}
/**
Meghíváskor a levegő cseréjét végzi el, ezt fél óránként egy percnyi működéssel végzi
*/
void legcsere() {
if (legcsereOn == 1) {
legcsereTimeOn = millis();
analogWrite(fanPin, fanSpeed);
legcsereOn = 0;
legcsereTime = millis();
}
else if (millis() - legcsereTimeOn > 60000) {
analogWrite(fanPin, 0);
fanStatus=0;
}
}
/**
A függvény ellenőrzi, hogy a vezérlő online van-e, és frissíti az időt.
Amennyiben a termesztés még nem kezdődött el, beállítja a termelés kezdőidőpontját
*/
void onlineCheck() {
lastOnline = online;
if (ArduinoCloud.getInternalTime() > reftime) {
online = 1;
if (growStartTime == "0") {
growStartTime = String(unixtime);
EEPROM_writelong(3, unixtime);
eeprWrite();
unixtime = ArduinoCloud.getInternalTime();
setTime(unixtime);
}
} else {
online = 0;
}
if (lastOnline != online) {
eeprWrite();
}
}
/**
Az arduino IoT Cloud működéséhez szükséges beállításokat végzi el
*/
void iotconfig() {
initProperties();
ArduinoCloud.begin(ArduinoIoTPreferredConnection);
setDebugMessageLevel(2);
ArduinoCloud.printDebugInfo();
// return ArduinoIoTPreferredConnection;
}
/**
A fényerő módosításokor megjelenő képernyő
*/
void changeLightScreen() {
display.setPartialWindow(0, 0 , 296, 128);
display.fillScreen(GxEPD_WHITE);
display.setCursor(118, 50);
display.drawInvertedBitmap(118, 10, light, 60, 60, GxEPD_BLACK);
display.setFont(&FreeSansBold9pt7b);
if (Volume < 10) {
display.setCursor(138, 100);
display.print(String(Volume) + "%");
}
if (Volume > 10 && Volume < 100) {
display.setCursor(136, 100);
display.print(String(Volume) + "%");
}
if (Volume == 100) {
display.setCursor(130, 100);
display.print(String(Volume) + "%");
}
while (display.nextPage());
}
/**
A képernyő másodpercenkénti frissítését végzi, itt az összes állapotjelző (hőmérséklet, stb) frissül
*/
void updateScreen() {
growpoint++;
if (growpoint > 3) {
growpoint = 0;
}
if (daynum > 10) {
growpoint = 4;
daynum = 11;
}
if (daynum == 0) {
daynum = 1;
}
display.setPartialWindow(0, 0 , 296, 128);
display.fillScreen(GxEPD_WHITE);
display.setTextColor(GxEPD_BLACK);
display.setFont(&FreeSans9pt7b);
display.setCursor(85, 17);
display.print("Did you know?");
display.setFont(&FreeSansBold9pt7b);
display.setCursor(cors[daynum - 1][0], 50);
display.print(didu[daynum - 1][0]);
display.setCursor(cors[daynum - 1][1], 70);
display.print(didu[daynum - 1][1]);
display.setCursor(0, 0);
display.drawInvertedBitmap(0, 0, loadingline, 296, 128, GxEPD_BLACK);
if (online == 1) {
display.drawInvertedBitmap(0, 0, onwifi, 30, 26, GxEPD_BLACK);
} if (online == 0) {
display.drawInvertedBitmap(0, 0, offwifi, 30, 24, GxEPD_BLACK);
}
if (growpoint == 0) {
display.setFont(&FreeSans9pt7b);
display.setCursor(10, 100);
display.print("Growing in progress");
}
if (growpoint == 1) {
display.setFont(&FreeSans9pt7b);
display.setCursor(10, 100);
display.print("Growing in progress.");
}
if (growpoint == 2) {
display.setFont(&FreeSans9pt7b);
display.setCursor(10, 100);
display.print("Growing in progress..");
}
if (growpoint == 3) {
display.setFont(&FreeSans9pt7b);
display.setCursor(10, 100);
display.print("Growing in progress...");
}
if (growpoint == 4) {
display.setFont(&FreeSans9pt7b);
display.setCursor(10, 100);
display.print("Enjoy your harvest!");
}
display.setCursor(235, 100);
display.print("Temp");
display.setFont(&FreeSansBold9pt7b);
display.setCursor(237, 120);
display.print(homerseklet);
if (millis() > 30000 && loadlineState < 190) {
display.fillRect(10, 110, loadlineState, 10, GxEPD_BLACK);
}
while (display.nextPage());
}
void dayCalc() {
if (growStartTime != "") {
daynum = int((now() - growStartTime.toInt()) / 86400);
if (daynum > 11) {
daynum = 11;
}
}
}
/**
Szenzorértékek olvasása, előző óta nem változott
*/
void sensorRead()
{
// para = dht.readHumidity();
// humwifi = para;
// homerseklet =(dht.readTemperature()*1.8)+32;
// tempwifi = homerseklet;
}
void read_encoder(){ // Interrupt Service Routine (ISR) to read the encoder functions
Result = (' '); // Clear the old result, let's see if we can get a new one
ReadValue = (analogRead(AnalogInput) + analogRead(AnalogInput) + analogRead(AnalogInput)) / 3; // Read the average value from the Analog Input A0
if ( ReadValue > 590 && ReadValue < 660 ) Result = ('M');
if ( ReadValue > 695 && ReadValue < 760 ) Result = ('U'); // So, P=581-620, and then U=651-740, and then D=771-860
if ( ReadValue > 870 && ReadValue < 940 ) Result = ('D'); // The 'window' values depend on the resistors used, and
if ( Result == (' ') ) ReadValue = 0;
show_encoder();
}
void show_encoder()
{
if ( ReadValue != 0 )
{
if (Result == 'U') Volume = Volume + 1;
if (Result == 'D') Volume = Volume - 1;
ReadValue = 0;
}
}
/**
A cloudban módosított értékek felhasználása. Ezek a függvények kerülnek automatikus meghívásra az állapotváltozás esetén.
*/
void onSwitchhChange() {
// Add your code here to act upon Switchh change
if (switchh == true)
{
digitalWrite(lightPin, HIGH);
fenyero=255;
ledStateTime = millis();
}
else
{
digitalWrite(lightPin, LOW);
ledStateTime = millis();
fenyero=0;
}
}
void onFenyeroChange() {
analogWrite(lightPin, fenyero);
ledStateTime = millis();
if(fenyero!=0){
switchh=1;
}else{switchh=0;}
}
/**
Since HumSatus is READ_WRITE variable, onHumSatusChange() is
executed every time a new value is received from IoT Cloud.
*/
void onHumSatusChange(){
}
/**
Ha a switchet a dashboardon bekapcsoljuk működik, amíg ki nem kapcsoljuk vagy fél perc el nem telik.
Ha a fél perc nem telik el, a rendszeres légfrissítésbe nem számít bele.
*/
void onFanStatusChange() {
// Add your code here to act upon FanStatus change
if (fanStatus == true)
{
legcsereTimeOn = millis();
analogWrite(fanPin, fanSpeed);
legcsereOn = 0;
}else{
analogWrite(fanPin, 0);
}
}
/**
onChange függvények, többsége használatlan, de szükséges definiálni
*/
void onTimestepChange() {
}
void onLastUpdateUnixChange() {
}
void onNowChange() {
}
void onGrowStartTimeChange() {
}
void onMessagesChange() {
}
void onTimezoneChange() {
}
unsigned long EEPROM_readlong(int address)
{
//use word read function for reading upper part
unsigned long dword = EEPROM_readint(address);
//shift read word up
dword = dword << 16;
// read lower word from EEPROM and OR it into double word
dword = dword | EEPROM_readint(address + 2);
return dword;
}
/*
Long és int értékek EEPROMban való tárolásához
*/
void EEPROM_writelong(int address, unsigned long value)
{
EEPROM_writeint(address + 2, word(value));
value = value >> 16;
EEPROM_writeint(address, word(value));
}
unsigned int EEPROM_readint(int address)
{
unsigned int word = word(EEPROM.read(address), EEPROM.read(address + 1));
return word;
}
void EEPROM_writeint(int address, int value)
{
EEPROM.write(address, highByte(value));
EEPROM.write(address + 1 , lowByte(value));
}
//Hálózat létrehozása és wifi jelszó bekérése
void configAP(){
Serial.println("AP creating...");
WiFi.mode(WIFI_AP);
WiFi.softAP("ESPap");
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/html", index_html, processor);
});
server.on("/get", HTTP_GET, [] (AsyncWebServerRequest *request) {
String pp;
String ss;
if (request->hasParam(ssidHTML)&&request->hasParam(passHTML)) {
pp = request->getParam(passHTML)->value();
ss = request->getParam(ssidHTML)->value();
writeFile("/ssid.txt",ss);
writeFile("/pass.txt",pp);
}
else {
pp = ss = "No message sent";
}
request->send(200, "text/text", pp+", "+ss);
});
server.begin();
Serial.println("AP and server created.");
}
String processor(const String& var){
if(var == "inputSSID"){
return readFile("/ssid.txt");
}
else if(var == "inputPASS"){
if(readFile("/pass.txt")!=""){
return "*********";
}
else{
return "";
}
}
return String();
}
void onCelParaChange(){}
void onFanSpeedChange(){}
void onLightOffTimeChange(){}
void onLightOnTimeChange(){}
void onParaCiklusChange(){}
void onParaPeriodChange(){}
void onParaSzenzorOffChange(){}
void initProperties(){
ArduinoCloud.setBoardId(DEVICE_LOGIN_NAME);
ArduinoCloud.setSecretDeviceKey(DEVICE_KEY);
ArduinoCloud.addProperty(growStartTime, READWRITE, ON_CHANGE, onGrowStartTimeChange);
ArduinoCloud.addProperty(messages, READWRITE, ON_CHANGE, onMessagesChange);
ArduinoCloud.addProperty(tempwifi, READ, ON_CHANGE, NULL);
ArduinoCloud.addProperty(celPara, READWRITE, ON_CHANGE, onCelParaChange);
ArduinoCloud.addProperty(fanSpeed, READWRITE, ON_CHANGE, onFanSpeedChange);
ArduinoCloud.addProperty(fenyero, READWRITE, ON_CHANGE, onFenyeroChange);
ArduinoCloud.addProperty(lightOffTime, READWRITE, ON_CHANGE, onLightOffTimeChange);
ArduinoCloud.addProperty(lightOnTime, READWRITE, ON_CHANGE, onLightOnTimeChange);
ArduinoCloud.addProperty(paraCiklus, READWRITE, ON_CHANGE, onParaCiklusChange);
ArduinoCloud.addProperty(paraPeriod, READWRITE, ON_CHANGE, onParaPeriodChange);
ArduinoCloud.addProperty(timezone, READWRITE, ON_CHANGE, onTimezoneChange);
ArduinoCloud.addProperty(humwifi, READ, ON_CHANGE, NULL);
ArduinoCloud.addProperty(fanStatus, READWRITE, ON_CHANGE, onFanStatusChange);
ArduinoCloud.addProperty(humSatus, READWRITE, ON_CHANGE, onHumSatusChange);
ArduinoCloud.addProperty(paraSzenzorOff, READWRITE, ON_CHANGE, onParaSzenzorOffChange);
ArduinoCloud.addProperty(switchh, READWRITE, ON_CHANGE, onSwitchhChange);
}