Access IP of stations connected to SoftAP

[JAndrassy]

wrap command AT+CWLIF

[atesin]

is this issue still open?

i was thinking something elaborated... but until not so realtime tough, i realized this is already done in AdvancedChatServer example with WiFiServer.accept() managing our own external array of connected clients.... though i dont know what event to listen when a client leaves, other than polling :/

maybe using client.status() or query some other way ... we talked this before but i dont remember, there was a situation when client disconnected but there are still data unread on his buffer.... maybe everytime we know there is no more data we should also check if client is still connected to remove him from array if not

the another elaborated solution could be make the Server.atCwlif() return an iterable object that retuns a Client on each loop, until null.... or make it directly return an array of clients, or sockets (i am worried about memory comsumption though)

or make it work similar to WiFi.scanNetworks(), passing an empty WiFiClient array to fill in, making it reentrant (what returns scanNetworks()?)

void loop()(
{
  WiFiClient client = WiFiServer.accept();
  if ( client )
    doSomethingWith(client);
}

void loop()(
{
  ClientsList clients = WiFi.atCwlif();
  while ( client = ClientList.next() )  // next, get, pull, pop, shift or whatever used in C/arduino
    doSomethingWith(client);
}

void loop()(
{
  WiFiClient clients[] = WiFi.atCwlif();
  int len = sizeof(clients) / sizeof(WiFiClient);
  for ( byte i = 0; i < len, ++i )
    doSomethingWith(clients[i]);
}

void loop()(
{
  WiFiClient clients[WIFIESPAT_LINKS_COUNT]; // how much ram consumes this?
  WiFi.atCwlif(clients);
  for ( byte i = 0; i < WIFIESPAT_LINKS_COUNT, ++i )
    doSomethingWith(clients[i]);
}

p.s: i want to thank your patience with me... i am not a programmer, i am totally autodidact about programming.... sometimes i found things very hard to understand and got a little anxious, that was the case with print(callback) ..... but now that i understand more or less how to pass functions to another function (like javascript), or functions that inherit/expand another one (like java), can say i use print(callback) eveywhere and run like silk :)

[JAndrassy]

stations which joined to SoftAP, not clients connected to a TCP server.

[atesin]

... so ports and sockets and buffers are meaningless.... what about something like this?...

struct Station
{
  IPAddress ip,
  byte mac[6]
};
Station stations[8]; // for max_conn see AT+CWSAP (how much ram does this consume?) 

void loop()(
{
  size_t len = WiFi.atCwlif(stations);
  for ( byte i = 0; i < len, ++i )
    doSomethingWith(stations[i]);
}

[JAndrassy]

yes something like that.
I would name the function softApStations

[atesin]

i was thinking a little.... i am looking the code, specially from WiFi.scanNetworks() to serve as a template for this new command (is almost copy+paste+modify)...

in documentation you say we can pass an optional parameter WiFiApData[] to fill the actual networks... and looking in the source it seems you should also pass the arrray length ... so what would happen in this situation?

WiFiApData networks[2];
WiFi.scanNetworks(networks); // with 8 networks found

could there be some way to autodetect the lenght or get it earlier, that is not necessary to pass the lenght for ease, to prevent overflows and not to waste too much ram at same time? maybe a 2 pass commands?

sorry for replying here, maybe this is a matter for a new issue but as i found with occasion of implementing this new command... anyway i think you flaw badly with command documentation, in some time i will check the source (collect public function signatures from .h files) and contribute with a more detailed api specification

[JAndrassy]

in C and C++ it is not possible to determine in the function the length of a basic array passed to the function. so the length must be always specified as a separate parameter. scanNetwork in your snippet without the second parameter would corrupt content of RAM. (so I guess it would be better to provide two functions, one without parameters as required by Arduino API and an optional version with two parameters)

[atesin]

inspired by classes in other languages... i think one efficient and secure way to do it could be in 2-pass , the first one just to return the stations count, to let user declare his array with exact size, and the second to fill the actual passed array

as you previously need the array to know the size, i think the first pass should do all the work and cache the stations in a global array WiFiStation[8] (8 is the max allowed connections according AT+CWSAP_CUR documentation)

the second pass will just copy the internal to passed array, and flushes resets or zerofills the caches to force the user work with updated data

however all this doesnt really prevent the user to declare an array of any size, wasting memory or povoking an overflow (and to keep a global array always is a counter sense)

... then the next approach could be to trust in user (after all we are all C programmers supposedly :) ) and let the user declare his array blindly to <max_size> (8 according AT+CWSAP) and receive and populate his empty array just in 1-pass

// instruct the user to use this macro to declare his WiFiStation[] array size
#define WIFIESPAT_STATIONS_LIST_SIZE 8

size_t WiFi.softApStations(WiFiStation stations[] = nullptr) // so a *pointer* to array is actually passed?, a shame we cant use sizeof()
{
  // send AT+CWLIF command and get data
  // just fill the passed array with stations found, or discard them if nullptr
  // return the stations count
}

... so the user is responsibile to optimize the arrays memory and cleanup things in his sketch, or do wtf he wants

side note: a nasty trick (possibly) i thought to detect array size could be like...

WiFiStation stations[anySize];
char* terminator; // be sure to declare it RIGHT AFTER the stations array

// could those vars be put in a struct to force the user to declare both vars and in that order? or structs must be fixed size?

size_t softApStations(WiFiStation stations[], char* terminator)
{
  // send command and get info...
  while ( currentStation != terminator ) // the idea is when pointers overlaps, then you reached the end of the array
  {
    // populate the array
    // advance the array pointer
  }
}

[JAndrassy]

esp8266 and esp32 Arduino have uint8_t softAPgetStationNum();
how is terminator better than size? and you can't compare struct/class with char.

the max count of stations of SoftAP is very low. it is max 8.

[atesin]

how is terminator better than size

you are right, this way you are also passing an additional parameter :/

you can't compare struct/class with char.

yes i know.. i didnt mean compare different data types but compare same address pointers, where they point, i dont know how to write it (with & ?)

if you declare 2 adjacent variables and get pointers to them, and you are incrementing the address of the first pointer, at sometime this will "overflow" to address of the next variable ... am i right? .... now i see this is not really practical, unless you pass a struct or class with builtin "length" property (like arduino String class, which in fact is a crap)

forget that and instead please focus in my first code snippet above, the WIFIESPAT_STATIONS_LIST_SIZE one... would it work?

[JAndrassy]

this could be the example:

uint8_t count = WiFi.softAPgetStationNum();
SoftAPStation stations[count];
WiFi.softAPStations(stations, count);
for (uint8_t i = 0; i < count; i++) {
  Serial.println(stations[i].ip);
}

[atesin]

yes but doesn't the arduino work twice this way? ... one to get count and other to fill the array? ... and don't you this way anyway need the internal global array of 8 stations, always occuppying memory even the user does not list ap's?

what to you think about the fixed size array of 8 (the possible max for the platform)?.... that way the user could create his own array[8] in some scope, use it, and then discard it releasing memory... or create a class like

// StationsList class: fill its internal array[8] at construct time, and have 3 methods
// - query stations count
// - copy stations array
// - destructor or whatever it names

StationsList stationsList; // fill the array[8] internaly
size_t stationsCount = stationsList.count();
WiFiStation stations[stationsCount]; // user creates his array of exact size
stationsList.fill(stations);
stationsList.destroy(); // release the array[8] and resources, anyway the array was already copied above
doSomethingWith(stations);

(.... however this way there will still exists 2 arrays at some time, occupying maybe the twice of ram :/ ...)

i think putting the responsibility on the user on create and pass a fixed size WiFiStation[WIFIESPAT_STATIONS_LIST_SIZE] array is a more light, fast, efficient and simple solution... what do you think?

[JAndrassy]

yes it works twice. user can decide if calls the function with a fixed array or first requests the size and the AT command will be processed twice. but yes the fixed size array is the better way and should be shown as example with WIFIESPAT_MAX_STATIONS_COUNT provided by the library.

Notes:

• the code you proposed in previous comment is really not a good way for arduino users.
• I implemented scan with internal array, to implement the scan API as in Arduino WiFi libraries. but I don't like it.

[atesin]

i see.... what would happen if a user query the stations count, then declare his empty array, then a new station connects, and then passes his empty array to a to fill a stations list? .. could be the list suddenly be a little longer to fit in the array? ....eeem, no because the user will also pass the list size parameter, right? (a security measure)

yes but anyway users can commit mistakes, like confuse variables and instead pass staListSize (4) pass sfaListSize (32) ... i was extensively thinking about this through the flow of this conversation, and until i am a perfectionist, i went to conclusion we shouldn't write a bulletproof lib to "protect" users to commit mistakes... is expensive (in developing time, cpu processing, space, etc) and we prevent them to learn by themselves, and dont prevent them either to mess around eventually

everybody knows arduino is a very constrained platform, and efficiency should be the priority.... many arduino apps are not "serious" ones, and many users use it to "play" and learn .. like many kids with his robot-arm or his light-board game .... serious projects are not so many (according my perception), so they are actually done by careful and skilled people

is not so bad to just warn the user about WIFIESPAT_MAX_STATIONS_COUNT array size and trust him... and if he fails... well, deal with it and learn! xD ... but the lib will be flash optimized! xD

• the code you proposed in previous comment is really not a good way for arduino users.

because what i am talking above right? .. insecure but optimized code? .. C is insecure by nature, if dont like go to java xD (no offense, i like java too)

.... while the arduino doesn't burn.......

• I implemented scan with internal array, to implement the scan API as in Arduino WiFi libraries. but I don't like it.

actually i dont like internal global arrays either (at least in arduino, in php with a 16gb server who cares), i imagine is always ocuppying ram and maybe nobody will use it :/ ... so i imagine you prefer to be parsing the data as you are reading from serial right? .. like with ser.readBytesUntil(',', fillBuffer, 32) ?? .. me too

p.s.: greetings from Chile