REFAcTOR.c

Go to the documentation of this file.

#define REFACTOR_MSG
#ifdef REFACTOR_MSG
            //!TODO: duplicate and depreciate these and replace with set:buzz,val:on
            else if (strcasecmp(setCmdString,"buzz")==0)
                {
            if (flag)
            {
                SerialDebug.println("BUZZON via BLE");
                main_dispatchAsyncCommand(ASYNC_CALL_BUZZ_ON);
            }
            else if (strcasecmp(cmd,"buzzoff")==0)
            {
                SerialDebug.println("BUZZOFF via BLE");
                main_dispatchAsyncCommand(ASYNC_CALL_BUZZ_OFF);
            }
                }
 
 
            //BLECLient
            else if (strcasecmp(setCmdString,"bleclient")==0)
                {
                if (flag)
            {
                if (deviceNameSpecified)
                {
                    SerialDebug.println("PREFERENCE_MAIN_BLE_CLIENT_VALUE ON via BLE");
                    savePreferenceBoolean_mainModule(PREFERENCE_MAIN_BLE_CLIENT_VALUE, true);
                    //!for now just reboot which will use this perference
                    rebootDevice_mainModule();
                }
            }
            else
            {
                if (deviceNameSpecified)
                {
                    SerialDebug.println("PREFERENCE_MAIN_BLE_CLIENT_VALUE OFF via BLE");
                    savePreferenceBoolean_mainModule(PREFERENCE_MAIN_BLE_CLIENT_VALUE, false);
                    //!for now just reboot which will use this perference
                    rebootDevice_mainModule();
                }
            }
                }
                // bleserver
            else if (strcasecmp(setCmdString,"bleserver")==0)
                {
            if (flag)
            {
                if (deviceNameSpecified)
                {
                    SerialDebug.println("PREFERENCE_MAIN_BLE_SERVER_VALUE ON via BLE");
                    savePreferenceBoolean_mainModule(PREFERENCE_MAIN_BLE_SERVER_VALUE, true);
                    //!for now just reboot which will use this perference
                    rebootDevice_mainModule();
                }
            }
            else
            {
                if (deviceNameSpecified)
                {
                    SerialDebug.println("PREFERENCE_MAIN_BLE_SERVER_VALUE OFF via BLE");
                    savePreferenceBoolean_mainModule(PREFERENCE_MAIN_BLE_SERVER_VALUE, false);
                    //!for now just reboot which will use this perference
                    rebootDevice_mainModule();
                }
            }
                }
 
            else if (strcasecmp(setCmdString,"tilt")==0)
                {
            if (flag)
            {
                SerialDebug.println("PREFERENCE_SENSOR_TILT_VALUE ON via BLE");
                savePreferenceBoolean_mainModule(PREFERENCE_SENSOR_TILT_VALUE, true);
            }
            else
            {
                SerialDebug.println("PREFERENCE_SENSOR_TILT_VALUE OFF via BLE");
                savePreferenceBoolean_mainModule(PREFERENCE_SENSOR_TILT_VALUE, false);
            }
                }
 
.....
            else if (strcasecmp(setCmdString,"zoomSm")==0)
                {
            //!zoom == the NON semantic marker version.. so min menu is true
              if (flag)
            {
 
                //hide semantic marker.. (but only if in the max menus)
                //NOTE: this only hides the Semantic Marker - if on a page that has one..
                SerialDebug.println("PREFERENCE_SEMANTIC_MARKER_ZOOMED_VALUE ON via BLE");
                savePreferenceBoolean_mainModule(PREFERENCE_SEMANTIC_MARKER_ZOOMED_VALUE, true);
 
                //!zoom only if in the max menu set..
                if (getCurrentSMMode_mainModule() >= minMenuModesMax_mainModule())
                {
                    //stay on this page, but change the marker..
                    redrawSemanticMarker_displayModule(START_NEW);
                }
 
            }
            else
            {
                //show semantic marker..
                //NOTE: this only shows the Semantic Marker - if on a page that has one..
                SerialDebug.println("PREFERENCE_SEMANTIC_MARKER_ZOOMED_VALUE OFF via BLE");
                savePreferenceBoolean_mainModule(PREFERENCE_SEMANTIC_MARKER_ZOOMED_VALUE, false);
                savePreferenceBoolean_mainModule(PREFERENCE_IS_MINIMAL_MENU_SETTING, false);
 
                //!zoom only if in the max menu set..
                if (getCurrentSMMode_mainModule() < minMenuModesMax_mainModule())
                {
                    //change to the status..
                    setCurrentSMMode_mainModule(SM_status);
                    //!send message to ourself to process the current mode..
                    invokeCurrentSMModePage(topic);
                }
                else
                {
                    //stay on this page, but change the zoom..
                    redrawSemanticMarker_displayModule(START_NEW);
                }
            }
                } // zoomSM
    #endif // REFACTOR
 
        }
        //! {'guest':'guest password'}
        else if (guestCmd)   //depreciated..
        {
            _mqttGuestPasswordString = const_cast<char*>(guestCmd);
            SerialDebug.printf("guestCmd = '%s'\n", _mqttGuestPasswordString);
        }
        // {'sm':'name/cat/uuid'}
        else if (semanticMarkerCmd)
        {
            //char semanticMarkerString[200];
            char* baseString = (char*)"https://SemanticMarker.org/bot/";
            sprintf(_semanticMarkerString,"%s/%s", baseString, semanticMarkerCmd);
 
            //! use the name/cat/uuid ..
            showSemanticMarker_displayModule(_semanticMarkerString, "Semantic address");
 
        }
        //!5.12.22
        else if (setCmd && valCmd)
        {
            //! options:  hightemp, feedcount, timeout
            char* setCmdString  = const_cast<char*>(setCmd);
            char* valCmdString = const_cast<char*>(valCmd);
            SerialTemp.print("Set: ");
            SerialTemp.print(setCmdString);
            SerialTemp.print(", Val: ");
            SerialTemp.println(valCmdString);
 
                // if boolean
            boolean flag = false;
            if (isTrueString(valCmdString))
               flag = true;
 
            //!try 5.12.22 {'set':'item'},{'val':'value'}
            //!   eg. set:hightemp, val:80)
            //!   TODO: confirm valid integer values...
            if (strcasecmp(setCmdString,"hightemp")==0)
            {
                //!set the high temp value..
                savePreferenceIntFromString_mainModule(PREFERENCE_HIGH_TEMP_POWEROFF_VALUE, valCmdString);
            }
            else if (strcasecmp(setCmdString,"screentimeout")==0)
            {
                //set the screen timeout
                savePreferenceIntFromString_mainModule(PREFERENCE_DISPLAY_SCREEN_TIMEOUT_VALUE, valCmdString);
            }
            else if (strcasecmp(setCmdString,"stepperangle")==0)
            {
                //!set the stepperangle.
                savePreference_mainModule(PREFERENCE_STEPPER_ANGLE_FLOAT_SETTING, valCmdString);
            }
            else if (strcasecmp(setCmdString,"noclick")==0)
            {
                //!set the timeout from no click to poweroff
                savePreferenceIntFromString_mainModule(PREFERENCE_NO_BUTTON_CLICK_POWEROFF_SETTING, valCmdString);
            }
            else if (strcasecmp(setCmdString,"gateway")==0)
            {
                boolean flag = false;
                if (isTrueString(valCmdString))
                    flag = true;
 
                //! called to set a preference (which will be an identifier and a string, which can be converted to a number or boolean)
                savePreferenceBoolean_mainModule(PREFERENCE_MAIN_GATEWAY_VALUE, flag);
            }
            //!add stepper type
            else if (strcasecmp(setCmdString,"stepper")==0)
            {
                int feederType = STEPPER_IS_UNO;
                if (strcasecmp(valCmdString,"mini")==0)
                    feederType = STEPPER_IS_MINI;
                else if (strcasecmp(valCmdString,"tumbler")==0)
                    feederType = STEPPER_IS_TUMBLER;
                //! called to set a preference (which will be an identifier and a string, which can be converted to a number or boolean)
                savePreferenceInt_mainModule(PREFERENCE_STEPPER_KIND_VALUE, feederType);
            }
            //!add stepper type
            else if (strcasecmp(setCmdString,"otafile")==0)
            {
                //perform the OTA via a file specified .. be careful..
                main_dispatchAsyncCommandWithString(ASYNC_CALL_OTA_FILE_UPDATE_PARAMETER, valCmdString);
            }
            //!set the location
            else if (strcasecmp(setCmdString,"location")==0)
            {
                //perform the OTA via a file specified .. be careful..
                _jsonLocationString = createCopy(valCmdString);
                updatePreferencesInEPROM();
            }
            //! rename device
            else if (strcasecmp(setCmdString,"device")==0)
            {
                //define the device
                _deviceNameString = createCopy(valCmdString);
                updatePreferencesInEPROM();
 
                //!since renaming, lets set a STATUS out..
                //! request a STATUS be sent.
                processBarkletMessage("#STATUS", topic);
            }
            //! paireddev the paired device
            else if (strcasecmp(setCmdString,"pairdev")==0)
            {
                //!saves the pair device name  TODO: the feed device should use the pair as well.. (DONE..)
                savePreference_mainModule(PREFERENCE_PAIRED_DEVICE_SETTING, valCmdString);
            }
 
            else if (strcasecmp(setCmdString,"screencolor")==0)
            {
                //!set the screen color 0..n
                int screenColor = atoi(valCmdString);
                setScreenColor_displayModule(screenColor);
 
                //stay on this page, but change the marker..
                redrawSemanticMarker_displayModule(START_NEW);
            }
            //! sets the gen3only flag
            else if (strcasecmp(setCmdString,"gen3only")==0)
            {
                boolean flag = isTrueString(valCmdString);
 
                //! sets the gen3only flag
                savePreferenceBoolean_mainModule(PREFERENCE_ONLY_GEN3_CONNECT_SETTING, flag);
                //!for now just reboot which will use this perference
                rebootDevice_mainModule();
            }
            //! sets the gen3only flag
            else if (strcasecmp(setCmdString,"bleusepaireddevicename")==0)
            {
                boolean flag = isTrueString(valCmdString);
 
                //! sets the bleusepaireddevicename flag
                savePreferenceBoolean_mainModule(PREFERENCE_BLE_USE_DISCOVERED_PAIRED_DEVICE_SETTING, flag);
 
            }
            //! sets the gen3only flag
            else if (strcasecmp(setCmdString,"bleusedevicename")==0)
            {
                boolean flag = isTrueString(valCmdString);
 
                //! sets the bleusedevicename flag
                savePreferenceBoolean_mainModule(PREFERENCE_BLE_SERVER_USE_DEVICE_NAME_SETTING, flag);
 
                //!for now just reboot which will use this perference and re-create the service name..
                rebootDevice_mainModule(); }
            else if (strcasecmp(setCmdString,"minMenu")==0)
            {
                SerialDebug.println("PREFERENCE_IS_MINIMAL_MENU_SETTING  via BLE");
                boolean flag = isTrueString(valCmdString);
                if (flag)
                {
                    setCurrentSMMode_mainModule(0);
                    savePreferenceBoolean_mainModule(PREFERENCE_IS_MINIMAL_MENU_SETTING, true);
                }
                else
                {
                    int max = minMenuModesMax_mainModule();
                    //set to start of after min..
                    setCurrentSMMode_mainModule(max);
                }
                //!send message to ourself to process the current mode..
                invokeCurrentSMModePage(topic);
            }
            else if (strcasecmp(setCmdString,"addwifi")==0)
            {
                //has to support "Cisco:"
                //parse the valCmdString:  ssid:password
                char str[100];
                strcpy(str,valCmdString);
                char *token;
                char *rest = str;
                char* ssid = strtok_r(rest,":", &rest);
                char* password = strtok_r(rest,":", &rest);
                SerialDebug.printf("addwifi %s, %s\n", ssid?ssid:"null", password?password:"");
                //now save as a credential
             //   main_addWIFICredentials(addSSID, addPassword);
                //!send message to ourself to process the current mode..
             //   invokeCurrentSMModePage(topic);
 
                //NOTE: there can be empty passwords..
                char credentials[100];
                //!store the JSON version of these credentials..
                sprintf(credentials, "{'ssid':'%s','ssidPassword':'%s'}", ssid?ssid:"NULL", password?password:"");
                // This works by just sending the credentials to ourself .. and process correctly.
                SerialMin.println(credentials);
                processJSONMessageMQTT(credentials, TOPIC_TO_SEND);
 
                //The problem with invoking the current SMModePage is if we are on the swap WIFI page, then it will swap .. which might not be desired..
            }
            else if (strcasecmp(setCmdString,"docfollow")==0)
            {
                SerialDebug.printf("PREFERENCE_USE_DOC_FOLLOW_SETTING %s\n", valCmdString);
                boolean flag = isTrueString(valCmdString);
                savePreferenceBoolean_mainModule(PREFERENCE_USE_DOC_FOLLOW_SETTING, flag);
 
            }
        }
        //!5.24.22  send:<request>  .. Note these are for cmd without an argument..
        else if (sendCmd)
        {
            //!NOTE: This will be calling ourself
 
            char* sendCmdString  = const_cast<char*>(sendCmd);
            if (strcasecmp(sendCmdString,"temp")==0)
            {
                SerialTemp.println("sendCmd == temp");
                //! request a TEMP be sent.
                processBarkletMessage("#TEMP", topic);
            }
            else if (strcasecmp(sendCmdString,"status")==0)
            {
                SerialTemp.println("sendCmd == status");
                //! request a STATUS be sent.
                processBarkletMessage("#STATUS", topic);
            }
            else if (strcasecmp(sendCmdString,"capture")==0)
            {
                SerialTemp.println("sendCmd == capture");
                //! request a CAPTURE be sent.
                processBarkletMessage("#CAPTURE", topic);
            }
            else if (strcasecmp(sendCmdString,"volume")==0)
            {
                SerialTemp.println("sendCmd == volume (not implemented)");
                //! request a VOLUME be sent.
                processBarkletMessage("#VOLUME", topic);
            }
            else
            {
                SerialTemp.print("Unknown send request: ");
                SerialTemp.println(sendCmdString);
            }
 
        }
 
        //!this return is important!!!
        return true;
    } //!end process commands..
 
    //end NEW
    //!TRY without 1.30.22 (RAMS win) and it works..
    //!if can talk BLE, then reboot..  2.2.22
 
    //NOTE: here is where different reasons for the info could be provided in the data>
    // eg. dataKind (wifi, mqtt, etc...)boot
    /**
     {
     "ssid" : "SunnyWhiteriver",
     "ssidPassword" : "sunny2021",
     "mqtt_topic": "usersP/bark/test",
     "mqtt_user" : "test",
     "deviceName" : "HowieFeeder",
     "mqtt_password" : "password..",
     "mqtt_guestPassword" : "password",
     "uuid" : "scott",
     "mqtt_port" : "1883",
     "mqtt_server" : "idogwatch.com",
     "mqtt_status" : "Success",
     "location": "whatever to reply with, GPS, state, city, etc.."
     }
 
     //todo pass the guest password too
     */
    //TODO: parse the string...
    //!! Store wifi config.  ␖å␖˜␖å␖¨wifi␖é␖␖ç␖®␖ä␖¡␖æ␖¯
    //! @see https://arduinojson.org
 
    {
        const char* a1 = myObject["ssid"];
        if (a1 && strlen(a1)>0)
        {
            _ssidString = const_cast<char*>(a1);
            _ssidString = createCopy(_ssidString);
        }
        else
            _ssidString = NULL;
 
        SerialTemp.println(a1);
        SerialTemp.println(_ssidString);
    }
 
    {
        const char* a2 = myObject["ssidPassword"];
        if (a2 && strlen(a2)>0)
        {
            _ssidPasswordString = const_cast<char*>(a2);
            _ssidPasswordString = createCopy(_ssidPasswordString);
        }
        else
            _ssidPasswordString = NULL;
    }
 
    {
        //!5.25.22 (50 years since Grateful Dead London Show
 
        //! To support just setting the ssid and password, a JSON
        //! of {ssid:s,ssidPassword:p} is supported, so don't null out if mqtt aren't provided..
        //! this should work (since the SSID is what's checked to go to the AP mode)
 
        //!the MQTT host/port/user/password  (topic is created in this code...)
        const char* a3 = myObject["mqtt_server"];
        if (a3)
        {
            _mqttServerString = const_cast<char*>(a3);
            _mqttServerString = createCopy(_mqttServerString);
        }
        //    else
        //        _mqttServerString = NULL;
    }
    {
        const char* a4 = myObject["mqtt_port"];
        if (a4)
        {
            _mqttPortString = const_cast<char*>(a4);
            _mqttPortString = createCopy(_mqttPortString);
        }
        //    else
        //        _mqttPortString = NULL;
        //
    }
    {
        const char* a5 = myObject["mqtt_password"];
        if (a5)
        {
            _mqttPasswordString = const_cast<char*>(a5);
            _mqttPasswordString = createCopy(_mqttPasswordString);
        }
        //    else
        //        _mqttPasswordString = NULL;
    }
 
    {
        const char* a6 = myObject["mqtt_user"];
        if (a6)
        {
            _mqttUserString = const_cast<char*>(a6);
            _mqttUserString = createCopy(_mqttUserString);
        }
        //    else
        //        _mqttUserString = NULL;
    }
    {
        const char* a7 = myObject["deviceName"];
        if (a7 && strlen(a7)>0)
        {
            _deviceNameString = const_cast<char*>(a7);
            _deviceNameString = createCopy(_deviceNameString);
        }
        //    else
        //        _deviceNameString = NULL;
    }
    {
        const char* a8 = myObject["uuid"];
        if (a8)
        {
            _uuidString = const_cast<char*>(a8);
            _uuidString = createCopy(_uuidString);
        }
        //    else
        //        _uuidString = NULL;
    }
    {
        const char* a9 = myObject["mqtt_topic"];
        if (a9)
        {
            _mqttTopicString = const_cast<char*>(a9);
            _mqttTopicString = createCopy(_mqttTopicString);
        }
        //    else
        //        _mqttTopicString = NULL;
 
    }
    {
        const char* a10 = myObject["mqtt_guestPassword"];
        if (a10)
        {
            _mqttGuestPasswordString = const_cast<char*>(a10);
            _mqttGuestPasswordString = createCopy(_mqttGuestPasswordString);
        }
        //    else
        //        _mqttGuestPasswordString = NULL;
    }
 
    {
        const char* a11 = myObject["location"];
        if (a11 && strlen(a11)>0)
        {
            _jsonLocationString = const_cast<char*>(a11);
            _jsonLocationString = createCopy(_jsonLocationString);
        }
        //    else
        //        _mqttGuestPasswordString = NULL;
    }
 
    //!reset the MQTT attempts
    _globalMQTTAttempts = 0;
 
    boolean saveJSONPreferences = true;
    //!setup the WIFI if the ssid string (at least) is specified
    if (!isEmptyString(_ssidString ))
    {
        SerialDebug.println("Setting WIFI from JSON parameters");
        //setupWIFI(_ssidString, _ssidPasswordString);
 
        //!new: go out and let the process work...
        //!set the state, then the 'loop' will call setupWIF(...)
        _WIFI_MQTTState = preSetupWIFI;
        startDelay_WIFI_MQTTState();
 
    }
    else
    {
        SerialDebug.println(" ***** ERROR .. no ssidString *** ");
        //!call the callback specified from the caller (eg. NimBLE_PetTutor_Server .. or others)
        callCallbackMain(CALLBACKS_MQTT, MQTT_CALLBACK_SOLID_LIGHT, (char*)"solidLight");
 
        saveJSONPreferences = false;
    }
 
 
    //!don't save the preferences, since it didn't have enough information..
    if (!saveJSONPreferences)
    {
        SerialDebug.println("**** Not saving JSON in preferences ***");
        return true;
    }
 
    //!NOTE: this writes over entire values, since it's a string vs an JSON object
    updatePreferencesInEPROM();
 
    //!new 4.8.22 .. trying to kick out of AP mode if the credentials are good..
    main_credentialsUpdated();
 
    //!putting here .. time might have gone too fast..
    _WIFI_MQTTState = preSetupWIFI;
    startDelay_WIFI_MQTTState();
 
 
    return true;
}
 
//!restart the WIFI and then MQTT connection
void restartWIFI_MQTTState()
{
    //let it know MQTT isn't running either
    _MQTTRunning = false;
 
    SerialTemp.println("restartWIFI_MQTTState");
    //putting here .. time might have gone too fast..
    _WIFI_MQTTState = preSetupWIFI;
    startDelay_WIFI_MQTTState();
 
}
 
//!just update the EPROM, and send that to the WIFI_AP module as well
void updatePreferencesInEPROM()
{
    DynamicJsonDocument myObject(1024);
 
    //!basically if only the ssid/pass are sent, that is all that's written to EPROM
    //!even if the other information is available.. So recreate the JSON instead..
    //!seems c++ you cannot re-use output as it just appends to it.. unreal
    String output2;
    myObject["ssid"] = _ssidString;
    myObject["ssidPassword"] = _ssidPasswordString;
    myObject["mqtt_server"] = _mqttServerString;
    myObject["mqtt_port"] = _mqttPortString;
    myObject["mqtt_password"] = _mqttPasswordString;
    myObject["mqtt_guestPassword"] = _mqttGuestPasswordString;
 
    myObject["mqtt_user"] = _mqttUserString;
    myObject["mqtt_topic"] = _mqttTopicString;
    myObject["deviceName"] = _deviceNameString;
    myObject["uuid"] = _uuidString;
    myObject["jsonHeader"] = _jsonHeaderString;
    myObject["jsonVersion"] = _jsonVersionString;
    myObject["location"] = _jsonLocationString;
 
 
    //!JSON
    serializeJson(myObject, output2);
 
    //!open the preferences
    _preferencesMQTTNetworking.begin(ESP_EPROM_NAME, false);
    SerialDebug.print("MQTTNetworking.Writing EPROM JSON = '");
    SerialDebug.print(output2);
    SerialDebug.println("'");
 
    //!save in EPROM
    _preferencesMQTTNetworking.putString(_preferencesJSONName, output2);
    //! Close the Preferences
    _preferencesMQTTNetworking.end();
 
    //! sets the MQTT user/password. It's up to the code to decide who needs to know (currently saves in the WIFI_APModule
    main_updateMQTTInfo(_ssidString, _ssidPasswordString, _mqttUserString, _mqttPasswordString, _mqttGuestPasswordString, _deviceNameString, _mqttServerString, _mqttPortString, _jsonLocationString);
 
    //!NEW: 2.21.22
    //!TRY: reading back..
    _preferencesMQTTNetworking.begin(ESP_EPROM_NAME, false);  //false=read/write..
    _fullJSONString = _preferencesMQTTNetworking.getString(_preferencesJSONName);
    SerialDebug.print("Reading.2 EPROM JSON = ");
    SerialDebug.println(_fullJSONString? _fullJSONString:"NULL");
 
    //!check ... _fullMessage
    //! Close the Preferences
    _preferencesMQTTNetworking.end();
 
    SerialDebug.println("Write to MQTTNetworking.eprom done!");
}
 
#endif //USE_MQTT_NETWORKING