initalize.ino File Reference

Functions
void	eepromBrightnessChooser (int addr)
	Retrieves and sets the brightness from EEPROM.
void	eepromRouterOptionChooser (int addr)
	Retrieves and sets the router option from EEPROM.
void	eepromWifiModeChooser (int addr)
	Retrieves and sets the Wi-Fi mode from EEPROM.
void	eepromPatternChooser (int addr)
	Retrieves and sets the pattern from EEPROM.
void	readAnotherPatternEEProm ()
	Reads and increments the pattern from EEPROM.
void	eepromReadChannelAndAddress (int addr1, int addr2, int addr3, int addr4, int addr5)
	Reads channel and address information from EEPROM.
void	littleFSLoadSettings ()
	Loads settings from LittleFS file system.
void	checkFilesInSetup ()
	Checks files in the LittleFS file system during setup.
void	wifiChooser (char router_array[], char pwd_array[])
	Configures Wi-Fi settings based on the selected mode.
void	fastLEDInit ()
	Initializes FastLED library and sets up LED strip.
void	fastLEDIndicate ()
	Indicates Wi-Fi mode using FastLED library.
void	fastLEDIndicateFast ()
	Indicates Wi-Fi mode using FastLED library with a faster sequence.

Function Documentation

checkFilesInSetup()

void checkFilesInSetup

(

)

Checks files in the LittleFS file system during setup.

This function iterates through all files in the root directory ("/"), checks their size, and deletes them if they exceed the maximum allowed size (maxPX). It also checks for file corruption by attempting to read a small portion of each file.

Parameters

None

Returns

None

Precondition

LittleFS must be initialized and mounted before calling this function.

Postcondition

Files exceeding maxPX size or detected as corrupted will be deleted.

Note

This function uses Serial for printing debug messages.

maxPX defines the maximum allowed file size.

{
  Dir dir = LittleFS.openDir("/");
 
  while (dir.next())
  {
    String fileName = dir.fileName();
    File file = dir.openFile("r");
 
    // Check file size
    size_t fileSize = file.size();
    Serial.print("Checking file: ");
    Serial.print(fileName);
    Serial.print(" - Size: ");
    Serial.println(fileSize);
 
    // If file size exceeds maxPX, delete it
    if (fileSize > maxPX)
    {
      Serial.print("File too large. Deleting: ");
      Serial.println(fileName);
      LittleFS.remove(fileName);
    }
    else
    {
      // Try to read a small portion of the file to detect corruption
      uint8_t buffer[10];
      if (file.read(buffer, sizeof(buffer)) != sizeof(buffer))
      {
        // File might be corrupted, unable to read
        Serial.print("Corrupted file detected. Deleting: ");
        Serial.println(fileName);
        LittleFS.remove(fileName);
      }
      else
      {
        Serial.println("File is valid.");
      }
    }
 
    file.close();
  }
}

References maxPX.

Referenced by setup().

Here is the caller graph for this function:

eepromBrightnessChooser()

void eepromBrightnessChooser

(

int

addr

)

Retrieves and sets the brightness from EEPROM.

Reads the brightness value from EEPROM, checks for validity, and sets the brightness accordingly.

Parameters

addr	The EEPROM address where the brightness value is stored.

Returns

None

Precondition

EEPROM is initialized and ready for use.

Postcondition

Brightness is set to the retrieved value or a default value if invalid.

Note

This function is used to initialize the brightness setting from EEPROM.

Uses global variables such as newBrightness.

Calls other functions such as EEPROM.read(), EEPROM.write(), and FastLED.setBrightness().

{
  ////////////////////////////////////////////////////////Eeprom Brightness///////////////////////////////////////////////////////////////////////
 
  // EEPROM.write(15, newBrightness); //testing only
  // EEPROM.commit();
  int readBRTeprom = int(EEPROM.read(addr)); // read channel info and change from ascii
  newBrightness = readBRTeprom;              // monitor this, had some problems with ascii
  if (newBrightness > 254 || newBrightness < 1)
  {
    EEPROM.write(15, 20); // set back to default dim brightness
    newBrightness = 20;
    ////Serial.println("EEProm error, newBrightness reset to 200");
  }
  else
  {
    newBrightness = 20; // just start with low brightness please, better this way
    ////Serial.print("newBrightness set to ");
    ////Serial.println(newBrightness);
  }
 
  FastLED.setBrightness(newBrightness); // should I be removing this becos https://github.com/FastLED/FastLED/wiki/FastLED-Temporal-Dithering
  FastLED.showColor(CRGB::Black);
}

References newBrightness.

Referenced by setup().

Here is the caller graph for this function:

eepromPatternChooser()

void eepromPatternChooser

(

int

addr

)

Retrieves and sets the pattern from EEPROM.

Reads the pattern value from EEPROM, checks for validity, and sets the pattern accordingly.

Parameters

addr	The EEPROM address where the pattern value is stored.

Returns

None

Precondition

EEPROM is initialized and ready for use.

Postcondition

Pattern is set to the retrieved value or a default value if invalid.

Note

This function is used to initialize the pattern setting from EEPROM.

Uses global variables such as patternChooser and pattern.

Calls other functions such as EEPROM.read(), EEPROM.write(), and readAnotherPatternEEProm().

Valid pattern values are 1-6, with 1 being the default.

If patternChooser is outside the valid range, pattern is set to 1 (default).

{
  patternChooser = int(EEPROM.read(addr));
  if (patternChooser == 1)
  {
    pattern = 1;
    EEPROM.write(10, 1); 
  }
  if (patternChooser == 2)
  {
    pattern = 2;
    EEPROM.write(10, 2); 
  }
  if (patternChooser == 3)
  {
    pattern = 3;
    EEPROM.write(10, 3); 
  }
  if (patternChooser == 4)
  {
    pattern = 4;
    EEPROM.write(10, 4); 
  }
  if (patternChooser == 5)
  {
    pattern = 5;
    EEPROM.write(10, 5); 
  }
  if (patternChooser == 6) // hard coded, todo: need variable here to add more patterns?
  { 
    EEPROM.write(10, 6); 
    readAnotherPatternEEProm(); // on/off switcher
  }
  if (patternChooser > 6)
  {
    EEPROM.write(10, 1); // set back to default
    pattern = 1;
  }
  if (patternChooser < 1)
  {
    EEPROM.write(10, 1); // set back to default
    pattern = 1;
  }
}

References pattern, patternChooser, and readAnotherPatternEEProm().

Referenced by setup().

Here is the call graph for this function:

Here is the caller graph for this function:

eepromReadChannelAndAddress()

void eepromReadChannelAndAddress	(	int	addr1,
		int	addr2,
		int	addr3,
		int	addr4,
		int	addr5 )

Reads channel and address information from EEPROM.

Retrieves channel and address values from EEPROM, performs validation, and sets global variables accordingly.

Parameters

addr1	EEPROM address for channel information.
addr2	EEPROM address for IP address octet D.
addr3	EEPROM address for IP address octet A.
addr4	EEPROM address for IP address octet B.
addr5	EEPROM address for IP address octet C.

Returns

None

Precondition

EEPROM is initialized and ready for use.

Postcondition

Channel and address information is read and validated.

Note

only apChannel is actually relevant currently.

This function is used to initialize channel and address settings from EEPROM.

Uses global variables apChannel, addrNumD, addrNumA, addrNumB, and addrNumC.

Calls other function EEPROM.read().

Valid channel values are 1-11.

If channel is outside the valid range, it is set to 4 (default).

{
  int readAPEeprom = int(EEPROM.read(addr1)); // read channel info (from EEPROM13) and change 
  apChannel = readAPEeprom;                   
 
  if (apChannel > 11 || apChannel < 1)
  {                      // 13 for SA, is it 14 for Australia?
    EEPROM.write(11, 1); 
    apChannel = 4;
  }
  else
  {
    
  }
  // SET IP:
  uint8_t readAddrEeprom = uint8_t(EEPROM.read(addr2)); 
  addrNumD = readAddrEeprom;   
  readAddrEeprom = uint8_t(EEPROM.read(addr3)); 
  addrNumA = readAddrEeprom;                   
  readAddrEeprom = uint8_t(EEPROM.read(addr4)); 
  addrNumB = readAddrEeprom;                    
  readAddrEeprom = uint8_t(EEPROM.read(addr5));
  addrNumC = readAddrEeprom;                    
}

References addrNumA, addrNumB, addrNumC, addrNumD, and apChannel.

Referenced by setup().

Here is the caller graph for this function:

eepromRouterOptionChooser()

void eepromRouterOptionChooser

(

int

addr

)

Retrieves and sets the router option from EEPROM.

Reads the router option value from EEPROM, checks for validity, and sets the router option accordingly.

Parameters

addr	The EEPROM address where the router option value is stored.

Returns

None

Precondition

EEPROM is initialized and ready for use.

Postcondition

Router option is set to the retrieved value or a default value if invalid.

Note

This function is used to initialize the router option setting from EEPROM.

Uses global variables such as routerOption.

Calls other functions such as EEPROM.read() and EEPROM.write().

Valid router option values are 0 (disabled) or 1 (enabled).

{
  int newRouter = int(EEPROM.read(addr));
  if (newRouter == 0 || newRouter > 1)
  { // this should take care of first run as well, when eeprom is not set (usually 255 or 0)
    newRouter = 0;
    routerOption = false;
  }
  else
  { // 1 for router
    routerOption = true;
  }
 
  EEPROM.write(100, newRouter);
  //      EEPROM.commit(); //this is done later I think
}

References routerOption.

Referenced by setup().

Here is the caller graph for this function:

eepromWifiModeChooser()

void eepromWifiModeChooser

(

int

addr

)

Retrieves and sets the Wi-Fi mode from EEPROM.

Reads the Wi-Fi mode value from EEPROM, checks for validity, and sets the Wi-Fi mode accordingly.

Parameters

addr	The EEPROM address where the Wi-Fi mode value is stored.

Returns

None

Precondition

EEPROM is initialized and ready for use.

Postcondition

Wi-Fi mode is set to the retrieved value or a default value if invalid.

Note

This function is used to initialize the Wi-Fi mode setting from EEPROM.

Uses global variables such as wifiModeChooser and routerOption.

Calls other functions such as EEPROM.read() and EEPROM.write().

Valid Wi-Fi mode values are 1 (main AP mode) and 2 (auxiliary AP mode).

If routerOption is false, Wi-Fi mode is set to 1 (main AP mode) by default.

wifiModeChooser used in wifiChooser()

{  
  if (routerOption) // ok this is set to toggle between two modes - I guess to make sure I don't get stuck?
  { 
    wifiModeChooser = int(EEPROM.read(addr));
    wifiModeChooser++; // take this out and it stays on router?
    if (wifiModeChooser == 2)
    {
      EEPROM.write(5, 2); // save
    }
    if (wifiModeChooser > 2)
    {
      wifiModeChooser = 1;
      EEPROM.write(5, 1); // set back to default
      wifiModeChooser = 1;
    }
    if (wifiModeChooser < 1)
    { // never happens, except for first run...
      wifiModeChooser = 1;
      EEPROM.write(5, 1); // set back to default
      wifiModeChooser = 1;
    }
  }
  else
  {                      // skip router option
    wifiModeChooser = 1; // 1 means main AP mode, with auxillary connected to main.
  }
}

References routerOption, and wifiModeChooser.

Referenced by setup().

Here is the caller graph for this function:

fastLEDIndicate()

void fastLEDIndicate

(

)

Indicates Wi-Fi mode using FastLED library.

Displays a sequence of colors on the LED strip to indicate the current Wi-Fi mode. If wifiModeChooser is 1, (AP Mode) displays a sequence of red or blue colors depending on the auxillary variable. If wifiModeChooser is not 1, (Router Mode) displays a sequence of green colors.

Returns

None

Precondition

FastLED library is initialized and ready for use.

Postcondition

LED strip displays a sequence of colors indicating the Wi-Fi mode.

Note

This function is used to provide a visual indication of the Wi-Fi mode.

Uses global variables wifiModeChooser, auxillary, and NUM_LEDS.

Calls other function FastLED.show() and FastLED.delay().

Todo

Consider simplifying the code by reducing repetition.

{
  // indicate wifi mode:
  //  //Serial.println("FASTLED NOW");
  if (wifiModeChooser == 1)
  {
    for (int i = 0; i < NUM_LEDS; i++)
    {
      // Set the i'th led to whatever
      if (auxillary)
      {
        leds[i] = CRGB::Red;
      }
      else
      {
        leds[i] = CRGB::Blue;
      }
      // Show the leds
      FastLED.show();
      // now that we've shown the leds, reset the i'th led to black
      leds[i] = CRGB::Black;
      // Wait a little bit before we loop around and do it again
      FastLED.delay(10);
    }
    for (int i = 0; i < NUM_LEDS; i++)
    {
      // Set the i'th led to whatever
      if (auxillary)
      {
        leds[i] = CRGB::Red;
      }
      else
      {
        leds[i] = CRGB::Blue;
      }
      // Show the leds
      FastLED.show();
      // now that we've shown the leds, reset the i'th led to black
      leds[i] = CRGB::Black;
      // Wait a little bit before we loop around and do it again
      FastLED.delay(10);
    }
    for (int i = 0; i < NUM_LEDS; i++)
    {
      // Set the i'th led to whatever
      if (auxillary)
      {
        leds[i] = CRGB::Red;
      }
      else
      {
        leds[i] = CRGB::Blue;
      }
      // Show the leds
      FastLED.show();
      // now that we've shown the leds, reset the i'th led to black
      if (auxillary)
      {
        leds[i] = CRGB::Red;
      }
      else
      {
        leds[i] = CRGB::Blue;
      }
      // Wait a little bit before we loop around and do it again
      FastLED.delay(10);
    }
 
    FastLED.delay(10);
  }
  else
  {
    for (int i = 0; i < NUM_LEDS; i++)
    {
      // Set the i'th led to whatever
      leds[i] = CRGB::Green;
      // Show the leds
      FastLED.show();
      // now that we've shown the leds, reset the i'th led to black
      leds[i] = CRGB::Black;
      // Wait a little bit before we loop around and do it again
      FastLED.delay(10);
    }
    for (int i = 0; i < NUM_LEDS; i++)
    {
      // Set the i'th led to whatever
      leds[i] = CRGB::Green;
      // Show the leds
      FastLED.show();
      // now that we've shown the leds, reset the i'th led to black
      leds[i] = CRGB::Black;
      // Wait a little bit before we loop around and do it again
      FastLED.delay(10);
    }
    for (int i = 0; i < NUM_LEDS; i++)
    {
      // Set the i'th led to whatever
      leds[i] = CRGB::Green;
      // Show the leds
      FastLED.show();
      // now that we've shown the leds, reset the i'th led to black
      leds[i] = CRGB::Green;
      // Wait a little bit before we loop around and do it again
      FastLED.delay(10);
    }
 
    FastLED.delay(10);
  }
 
  FastLED.showColor(CRGB::Black);
}

References auxillary, leds, NUM_LEDS, and wifiModeChooser.

Referenced by setup().

Here is the caller graph for this function:

fastLEDIndicateFast()

void fastLEDIndicateFast

(

)

Indicates Wi-Fi mode using FastLED library with a faster sequence.

Displays a faster sequence of colors on the LED strip to indicate the current Wi-Fi mode. If wifiModeChooser is 1, (AP Mode) displays a sequence of magenta or cyan colors depending on the auxillary variable. If wifiModeChooser is not 1, (Router Mode) displays a sequence of green colors.

Returns

None

Precondition

FastLED library is initialized and ready for use.

Postcondition

LED strip displays a faster sequence of colors indicating the Wi-Fi mode.

Note

This function is used to provide a faster visual indication of the Wi-Fi mode.

Uses global variables wifiModeChooser, auxillary, and NUM_LEDS.

Calls other function FastLED.show() and FastLED.delay().

Todo

Consider simplifying the code by reducing repetition.

{
  // indicate wifi mode:
  //  //Serial.println("FASTLED NOW");
  if (wifiModeChooser == 1)
  {
    for (int i = 0; i < NUM_LEDS; i += 2)
    {
      // Set the i'th led to whatever
      if (auxillary)
      {
        leds[i] = CRGB::Magenta;
      }
      else
      {
        leds[i] = CRGB::Cyan;
      }
 
      // Show the leds
      FastLED.show();
      // now that we've shown the leds, reset the i'th led to black
      leds[i] = CRGB::Black;
      // Wait a little bit before we loop around and do it again
      FastLED.delay(15);
    }
    for (int i = 0; i < NUM_LEDS; i += 2)
    {
      // Set the i'th led to whatever
      if (auxillary)
      {
        leds[i] = CRGB::Magenta;
      }
      else
      {
        leds[i] = CRGB::Cyan;
      }
      // Show the leds
      FastLED.show();
      // now that we've shown the leds, reset the i'th led to black
      leds[i] = CRGB::Black;
      // Wait a little bit before we loop around and do it again
      FastLED.delay(15);
    }
    for (int i = 0; i < NUM_LEDS; i++)
    {
      // Set the i'th led to whatever
      leds[i] = CRGB::Black;
      // now that we've shown the leds, reset the i'th led to black
      if (auxillary)
      {
        leds[0] = CRGB::Magenta;
        leds[2] = CRGB::Magenta;
        leds[4] = CRGB::Magenta;
        leds[NUM_PX / 2] = CRGB::Magenta;
        leds[NUM_LEDS - 2] = CRGB::Magenta;
        leds[NUM_LEDS - 4] = CRGB::Magenta;
        leds[NUM_LEDS - 6] = CRGB::Magenta;
      }
      else
      {
        leds[0] = CRGB::Cyan;
        leds[2] = CRGB::Cyan;
        leds[4] = CRGB::Cyan;
        leds[NUM_PX / 2] = CRGB::Cyan;
        leds[NUM_LEDS - 2] = CRGB::Cyan;
        leds[NUM_LEDS - 4] = CRGB::Cyan;
        leds[NUM_LEDS - 6] = CRGB::Cyan;
      }
      // Show the leds
      FastLED.show();
      // Wait a little bit before we loop around and do it again
      // FastLED.delay(10);
    }
 
    // FastLED.delay(10);
  }
  else
  {
    for (int i = 0; i < NUM_LEDS; i++)
    {
      // Set the i'th led to whatever
      leds[i] = CRGB::Green;
      // Show the leds
      FastLED.show();
      // now that we've shown the leds, reset the i'th led to black
      leds[i] = CRGB::Black;
      // Wait a little bit before we loop around and do it again
      // FastLED.delay(10);
    }
    for (int i = 0; i < NUM_LEDS; i++)
    {
      // Set the i'th led to whatever
      leds[i] = CRGB::Green;
      // Show the leds
      FastLED.show();
      // now that we've shown the leds, reset the i'th led to black
      leds[i] = CRGB::Black;
      // Wait a little bit before we loop around and do it again
      // FastLED.delay(10);
    }
    for (int i = 0; i < NUM_LEDS; i++)
    {
      // Set the i'th led to whatever
      leds[i] = CRGB::Green;
      // Show the leds
      FastLED.show();
      // now that we've shown the leds, reset the i'th led to black
      leds[i] = CRGB::Green;
      // Wait a little bit before we loop around and do it again
      // FastLED.delay(10);
    }
 
    // FastLED.delay(10);
  }
 
  FastLED.showColor(CRGB::Black);
}

References auxillary, leds, NUM_LEDS, NUM_PX, and wifiModeChooser.

Referenced by setup().

Here is the caller graph for this function:

fastLEDInit()

void fastLEDInit

(

)

Initializes FastLED library and sets up LED strip.

Configures FastLED with the specified LED type (WS2812B), data pin (DATA_PIN), and color order (GRB), and sets the initial brightness (newBrightness) and color (black).

Returns

None

Precondition

FastLED library is included and ready for use.

Postcondition

FastLED is initialized and LED strip is set up.

Note

This function is used to initialize FastLED and set up the LED strip.

Uses global variables DATA_PIN, CLOCK_PIN, NUM_LEDS, and newBrightness.

Calls other functions FastLED.addLeds(), FastLED.setBrightness(), and FastLED.showColor().

Sets initial brightness to a low value for startup battery saving.

{
 
  ////////////////////////////////////////////////Fast LED Setup: ////////////////////////////////////////////////////////////////////////////////////////////////
  // FastLED.addLeds<APA102, DATA_PIN, CLOCK_PIN, BGR>(leds, NUM_LEDS); //DATA_RATE_MHZ(8)
  //  FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
  LEDS.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(newBrightness); // should be low figure here, for startup battery saving...
 
  FastLED.showColor(CRGB::Black);
 
  // if DNSServer is started with "*" for domain name, it will reply with
  // provided IP to all DNS request
  ///////////////////////////////////////////////////////////////////////end FastLED setup///////////////////////////////////////////////////////////////////
}

References DATA_PIN, leds, newBrightness, and NUM_LEDS.

Referenced by setup().

Here is the caller graph for this function:

littleFSLoadSettings()

void littleFSLoadSettings

(

)

Loads settings from LittleFS file system.

Reads settings from /settings.txt file and stores them in global variables.

Returns

None

Precondition

LittleFS file system is initialized and ready for use.

Postcondition

Settings are read and stored in global variables.

Note

This function is used to initialize settings from LittleFS.

Uses global variables router_array and pwd_array.

Calls other functions wifiChooser() and webServerSetupLogic().

Warning

Password is stored in plain text, posing a security risk.

Todo

Consider encrypting password for security.

{
  settings = LittleFS.open("/settings.txt", "r");
  // note: password is stored in plain text, security risk?
  // currently settings.txt avaliable on demand over http!
 
  // load spiffs into char arrays for router setup:
  //  Define
  Field = settings.readStringUntil('\n');
 
  // Length (with one extra character for the null terminator)
  // int router_len = router.length() + 1;
  // Prepare the character array (the buffer)
  // below should be part of Struct
  char router_array[Field.length() + 1];
  // Copy it over
  Field.toCharArray(router_array, Field.length() + 1);
 
  // and again for password:
  // Define
  Field = settings.readStringUntil('\n');
  // Length (with one extra character for the null terminator)
  // int pwd_len = pwd.length() + 1;
  // Prepare the character array (the buffer)
  char pwd_array[Field.length() + 1];
  // Copy it over
  Field.toCharArray(pwd_array, Field.length() + 1);
 
  settings.close();
  // delay(100);
  ///////////////////////////////////////////////////////////////End Read Settings////////////////////////////////////////////////////////////////////////////
  // more setup below, has to be inside this function...???
  wifiChooser(router_array, pwd_array);
  webServerSetupLogic(router_array, pwd_array); // why not do this only on AP mode?
}

References Field, settings, webServerSetupLogic(), and wifiChooser().

Referenced by setup().

Here is the call graph for this function:

Here is the caller graph for this function:

readAnotherPatternEEProm()

void readAnotherPatternEEProm

(

)

Reads and increments the pattern from EEPROM.

Reads the pattern value from EEPROM, increments it, and writes it back to EEPROM.

Returns

None

Precondition

EEPROM is initialized and ready for use.

Postcondition

Pattern is incremented and written back to EEPROM.

Note

This function is used to cycle through patterns on each restart.

Uses global variable pattern.

Calls other function EEPROM.write().

Valid pattern values are 1-5, with 1 being the default.

If pattern is outside the valid range, it is set back to 1 (default).

{
  // EEProm Pattern chooser: changes every time you restart poi 
  pattern = int(EEPROM.read(11));
  pattern++;
  if (pattern == 2)
  {
    EEPROM.write(11, 2); 
  }
  if (pattern == 3)
  {
    EEPROM.write(11, 3); 
  }
  if (pattern == 4)
  {
    EEPROM.write(11, 4); 
  }
  if (pattern == 5)
  {
    EEPROM.write(11, 5); 
  }
  if (pattern > 5)
  {
    EEPROM.write(11, 1); // set back to default
    pattern = 1;
  }
  if (pattern < 1)
  {
    EEPROM.write(11, 1); // set back to default
    pattern = 1;
  }
}

References pattern.

Referenced by eepromPatternChooser().

Here is the caller graph for this function:

wifiChooser()

void wifiChooser	(	char	router_array[],
		char	pwd_array[] )

Configures Wi-Fi settings based on the selected mode.

Sets up Wi-Fi in either Access Point (AP) mode, Station mode, or connects to a pre-defined router.

Parameters

router_array	Router SSID (used in Station mode).
pwd_array	Router password (used in Station mode).

Returns

None

Precondition

Wi-Fi library is initialized and ready for use.

Postcondition

Wi-Fi settings are configured according to the selected mode.

Note

This function is used to configure Wi-Fi settings based on the wifiModeChooser variable.

Uses global variables wifiModeChooser, auxillary, apName, apPass, apIP, apChannel, addrNumA, addrNumB, addrNumC, and addrNumD.

Calls other functions WiFi.mode(), WiFi.begin(), WiFi.config(), WiFi.softAP(), dnsServer.start(), and WiFiMulti.addAP().

Supports up to 18 connection attempts in Station mode.

Todo

Consider implementing exponential backoff for connection attempts.

{
  if (wifiModeChooser == 1)
  { // main AP mode, with auxillary connected to main.
    // this is all that is needed to put main and auxillary poi on one code base:
    if (auxillary)
    {
      // Serial.println("auxillary POI");
      WiFi.mode(WIFI_STA);
      WiFi.begin(apName, apPass);
      WiFi.config(apIPauxillary, ipGatewayauxillary, ipSubnet, ipGatewayauxillary);
      while (WiFi.status() != WL_CONNECTED)
      {
        if (millis() > 20000)
        {
          // don't wait if > 1 minute!
          break;
        }
        // Serial.print(".");
        FastLED.delay(50); // was set to 500, why? todo: does FastLED.delay() work better?
      }
      // LED on test:
      //  digitalWrite(LED_BUILTIN, LOW);
    }
    else
    { // main poi here
      // Serial.println("main POI");
      WiFi.mode(WIFI_AP);
      WiFi.softAPConfig(apIP, apIP, IPAddress(255, 255, 255, 0));
      WiFi.softAP(apName, apPass, apChannel); // use pre-set values here
      dnsServer.start(DNS_PORT, "*", apIP);   // AP mode only, surely??
 
      // wait for station:
      while (WiFi.softAPgetStationNum() == 0)
      {
        if (millis() > 10000)
        {
          // don't wait if > 1 minute!
          break;
        }
        FastLED.delay(50);
      }
      // LED on test:
      //  digitalWrite(LED_BUILTIN, LOW);
    }
  }
  else
  { // both main and auxillary the same, connected to pre-defined Router
    // Serial.println("ROUTER");
    //////////////////////////////////////////////////////////Connect to Router here://///////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////Input Settings from Spiffs: ////////////////////////////////////////////////////////////////////
    WiFi.mode(WIFI_STA); // disable AP on this one
    tmpIP = IPAddress(addrNumA, addrNumB, addrNumC, addrNumD);
    tmpGateway = IPAddress(addrNumA, addrNumB, addrNumC, 1); // make last another variable? YA!
    WiFiMulti.addAP(router_array, pwd_array); 
    byte wifiConnectAttemptCount = 0;
    byte maxWifiConnectAttemptCount = 18; // this should be in adjustable settings
 
    while (WiFiMulti.run() != WL_CONNECTED)
    {
      ///////////////////indicate://///////////////////////////////
      FastLED.showColor(CRGB::Black);
      for (int i = 0; i < uploadCounter; i++)
      {
        leds[i * 2] = CRGB::Green; // For max 18 tries, spacing out indicator
      }
      FastLED.show();
      uploadCounter++;
      //////////////////end indicate////////////////////////////////
 
      delay(500); // delay??? todo: try FastLED.delay() here, also 50ms instead of 500... Must be a better way..?
      wifiConnectAttemptCount++;
      if (wifiConnectAttemptCount > maxWifiConnectAttemptCount)
      {
        ESP.restart(); // Note: this won't work the first time, needs manual restart!!!!!!!!
      }
    }
    
    uploadCounter = 1;
  }
 
}

References addrNumA, addrNumB, addrNumC, addrNumD, apChannel, apIP(), apIPauxillary(), apName, apPass, auxillary, DNS_PORT, dnsServer, ipGatewayauxillary(), ipSubnet(), leds, tmpGateway(), tmpIP(), uploadCounter, wifiModeChooser, and WiFiMulti.

Referenced by littleFSLoadSettings().

Here is the call graph for this function:

Here is the caller graph for this function: