#include <WiFi.h>
#include <LiquidCrystal_I2C.h>
#include "button.h"

LiquidCrystal_I2C lcd(0x27, 16, 2);

button_ button(2, INPUT_PULLUP);

const char* ssid = "Wokwi-GUEST";
const char* password = "";

byte networkItem = 0;
byte netsAmount = 0;

void setup() {
  lcd.init();
  lcd.backlight();

  WiFi.begin(ssid, password);
  lcd.clear();
  lcd.print("Connecting to");
  lcd.setCursor(0, 1);
  lcd.print("Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)
  {
    lcd.setCursor(5, 1);
    lcd.print("   ");
    delay(300);
    lcd.setCursor(5, 1);
    lcd.print('.');
    delay(300);
    lcd.print('.');
    delay(300);
    lcd.print('.');
    delay(300);
  }

  lcd.clear();
  lcd.print("Connected");

  netsAmount = WiFi.scanNetworks();
  lcd.clear();
  lcd.print("Amount of");
  lcd.setCursor(0, 1);
  lcd.print("networks: ");
  lcd.print(netsAmount);
  delay(2000);
  lcdWorker();
}

void lcdWorker()
{
  lcd.clear();
  lcd.print("SSID:");
  lcd.print(WiFi.SSID(networkItem));
  lcd.setCursor(0, 1);
  lcd.print("RSSI:");
  lcd.print(WiFi.RSSI(networkItem));
}

void buttonHandler()
{
  if (button.onPressed()) {
    if (networkItem < (netsAmount - 1)) networkItem++;
    else networkItem = 0;

    lcdWorker();
  }
}

void loop() {
  buttonHandler();
}

sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

LiquidCrystal I2C


libraries.txt

#ifndef TIMER
#define TIMER

#include <Arduino.h>

class timer_ {
  public:
    timer_(unsigned long duration);
    void setTimeout(unsigned long duration);
    bool isExpired();
    void restart();
    void stop();

  private:
    unsigned long timeout  = 0;
    unsigned long waypoint = 0;
    enum {ACTIVE, EXPIRED, STOPPED} state = EXPIRED;

    unsigned long getValue();
    void updateState();
};

#endif

timer.h

#include "timer.h"

timer_::timer_(unsigned long duration) {
  setTimeout(duration);
}

void timer_::setTimeout(unsigned long duration) {
  timeout = (duration > 0) ? duration : 1;
}

bool timer_::isExpired()
{
  updateState();
  return state == EXPIRED;
}

void timer_::restart() {
  waypoint = millis();
  state = ACTIVE;
}

void timer_::stop() {
  state = STOPPED;
}

unsigned long timer_::getValue() {
  return millis() - waypoint;
}

void timer_::updateState() {
  if (state == ACTIVE && getValue() >= timeout) {
    state = EXPIRED;
  }
}

timer.cpp

#ifndef BUTTON
#define BUTTON

#include <Arduino.h>
#include "timer.h"

class button_
{
  public:
    button_(int pin, byte input);
    bool isPressed();
    bool isReleased();
    bool onPressed();
    bool onReleased();
    void invertReading(bool invert);

  private:
    byte _pin = 0;
    bool _invert = true;
    bool state = true;
    bool tempState = false;
    bool has_been_pressed  = false;
    bool has_been_released = false;

    void updateState();
    void inputMode(bool pullup);
    timer_ debounceTimer;
};

#endif

button.h

#include "button.h"

button_::button_(int pin, byte input) : debounceTimer(10)
{
  _pin = pin;

  if (input != 0) input = INPUT_PULLUP;
  pinMode(_pin, input);
}

bool button_::isPressed() {
  updateState();
  if (_invert) {
    return !state;
  }
  else {
    return state;
  }
}

bool button_::isReleased() {
  return !isPressed();
}

bool button_::onPressed()
{
  if (isPressed() && !has_been_pressed) {
    return has_been_pressed = true;
  }
  return false;
}

bool button_::onReleased()
{
  if (isReleased() && !has_been_released) {
    return has_been_released = true;
  }
  return false;
}

void button_::invertReading(bool invert) {
  _invert = invert;
}

void button_::updateState()
{
  if (debounceTimer.isExpired()) {
    tempState = digitalRead(_pin);
    if (state != tempState) {
      debounceTimer.restart();
      state = tempState;
      if (_invert) {
        if (state) {
          has_been_pressed = false;
        }
        else {
          has_been_released = false;
        }
      } else {
        if (state) {
          has_been_released = false;
        }
        else {
          has_been_pressed = false;
        }
      }
    }
  }
}