sketch.ino

diagram.json

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#include <Arduino.h>
#include "beaconspam.h"
#include "icons.h"
#include <esp_wifi.h>

extern Adafruit_ST7735 tft;

const uint16_t ORANGE = 0xfbe4;
const uint16_t BLACK = 0;

#define BTDOWNDTN  25
#define BTUP       21
#define BTDOWND    22

String alfa = "1234567890qwertyuiopasdfghjkklzxcvbnm QWERTYUIOPASDFGHJKLZXCVBNM_";
uint8_t spamchannel = 1;
bool spam = false;

// Beacon Packet buffer
uint8_t packet[128] = {0x80, 0x00, 0x00, 0x00,
                      /*4*/   0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
                      /*10*/  0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
                      /*16*/  0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
                      /*22*/  0xc0, 0x6c,
                      /*24*/  0x83, 0x51, 0xf7, 0x8f, 0x0f, 0x00, 0x00, 0x00,
                      /*32*/  0x64, 0x00,
                      /*34*/  0x01, 0x04,
                      /* SSID */
                      /*36*/  0x00, 0x06, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72,
                      0x01, 0x08, 0x82, 0x84,
                      0x8b, 0x96, 0x24, 0x30, 0x48, 0x6c, 0x03, 0x01,
                      /*56*/  0x04};

void pressBt01() {
  static unsigned long last_interrupt_time = 0;
  unsigned long interrupt_time = millis();
  if (interrupt_time - last_interrupt_time > 200) {
    if (spamchannel < 14) {
      spamchannel++;
    } else {
      spamchannel = 1;
    }
  }
  last_interrupt_time = interrupt_time;
}

void pressBt02() {
  spam = !spam;
}

void pressBt03() {}

void spammer() {
  // Randomize channel
  esp_wifi_set_channel(spamchannel, WIFI_SECOND_CHAN_NONE);

  // Randomize SRC MAC
  for (int i = 10; i <= 21; i++) {
    packet[i] = random(256);
  }

  // Randomize SSID
  for (int i = 38; i <= 43; i++) {
    packet[i] = alfa[random(65)];
  }

  packet[56] = spamchannel;

  // Send the packet
  esp_wifi_80211_tx(WIFI_IF_STA, packet, 57, false);

  delay(1);
}

void beaconspamSetup() {

  tft.fillScreen(ST7735_BLACK);

  // Set WiFi mode to NULL mode (monitor mode)
  esp_wifi_set_mode(WIFI_MODE_NULL);

  // Disconnect from any previous network
  esp_wifi_disconnect();

  // Initialize the ESP-IDF event loop
  esp_err_t ret = esp_event_loop_create_default();
  if (ret != ESP_OK) {
    ESP_LOGE("setup", "Error creating event loop: %d", ret);
    return;
  }

  // Initialize and configure Wi-Fi driver with default configuration
  wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
  ret = esp_wifi_init(&cfg);
  if (ret != ESP_OK) {
    ESP_LOGE("setup", "Error initializing Wi-Fi: %d", ret);
    return;
  }

  // Start the Wi-Fi driver
  ret = esp_wifi_start();
  if (ret != ESP_OK) {
    ESP_LOGE("setup", "Error starting Wi-Fi: %d", ret);
    return;
  }

  // Configure the Wi-Fi driver for promiscuous mode
  ret = esp_wifi_set_promiscuous(true);
  if (ret != ESP_OK) {
    ESP_LOGE("setup", "Error enabling promiscuous mode: %d", ret);
    return;
  }

  pinMode(BTDOWNDTN, INPUT_PULLUP);
  pinMode(BTUP, INPUT_PULLUP);
  pinMode(BTDOWND, INPUT_PULLUP);

  tft.fillScreen(ST7735_BLACK);
}

void beaconspamLoop() {
  attachInterrupt(digitalPinToInterrupt(BTUP), pressBt01, FALLING);
  attachInterrupt(digitalPinToInterrupt(BTDOWNDTN), pressBt02, FALLING);
  attachInterrupt(digitalPinToInterrupt(BTDOWND), pressBt03, FALLING);

  tft.fillRect(70, 0, 80, 20, ST7735_BLACK);
  tft.setFont();
  tft.setTextWrap(false);
  tft.setTextColor(ORANGE);
  tft.setTextSize(1);

  tft.setCursor(2, 2);
  tft.print("channel:");

  tft.setCursor(105, 2);
  tft.print("[");
  tft.print(spamchannel);
  tft.println("]");

  tft.setCursor(2, 13);
  tft.print("progress:");

  tft.setCursor(80, 13);
  tft.print("disabled");

  delay(500);

  if (spam) {
    tft.fillRect(70, 10, 80, 10, ST7735_BLACK);
    tft.setTextColor(ORANGE);
    tft.setCursor(85, 13);
    tft.print("enabled");

    tft.fillRect(0, 45, 128, 150, ST7735_BLACK);

    tft.setCursor(2, 45);
    tft.print("beginning");

    for (int i = 0; i < 5; i++) {
      tft.print(".");
      delay(500);
    }
    delay(1000);

    tft.setCursor(2, 60);
    tft.print(" set channel");
    tft.print(" [");
    tft.print(spamchannel);
    tft.print("]");
    delay(700);

    tft.setCursor(2, 75);
    tft.print(" SSID generated");
    delay(300);

    tft.setCursor(2, 90);
    tft.print(" Randomize SRC MAC");
    delay(500);

    tft.setCursor(2, 110);
    tft.print(" start broadcast");
    delay(500);
  }

  while (spam) {
    spammer();
  }
}


beaconspam.cpp

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#ifndef beaconspam_h
#define beaconspam_h

#include <Arduino.h>

#include <Adafruit_GFX.h>   
#include <Adafruit_ST7735.h> 
#include <SPI.h>

void beaconspamSetup();
void beaconspamLoop();

#endif


beaconspam.h

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#include <Arduino.h> 
#include "deauth.h"

extern Adafruit_ST7735 tft;


void deauthSetup(){
  
}


void deauthLoop(){
  
}


deauth.cpp

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#ifndef deauth_h
#define deauth_h

#include <Arduino.h>

#include <Adafruit_GFX.h>   
#include <Adafruit_ST7735.h> 
#include <SPI.h>

void deauthSetup();
void deauthLoop();

#endif


deauth.h

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#include <Arduino.h>
#include "detector.h"

extern Adafruit_ST7735 tft;

#include "freertos/FreeRTOS.h"
#include "esp_wifi.h"
#include "esp_wifi_types.h"
#include "esp_system.h"
#include "esp_event.h"
#include "esp_event_loop.h"
#include "nvs_flash.h"
#include <stdio.h>
#include <string>
#include <cstddef>
#include <Wire.h>
#include <Preferences.h>
using namespace std;

const uint16_t GRAY = 303131;
const uint16_t BLUE = 0x001f;
const uint16_t RED = 0xf800;
const uint16_t GREEN = 0x07e0;
const uint16_t BLACK = 0;
const uint16_t YELLOW = RED + GREEN;
const uint16_t CYAN = GREEN + BLUE;
const uint16_t MAGENTA = RED + BLUE;
const uint16_t WHITE = RED + BLUE + GREEN;
const uint16_t ORANGE = 0xfbe4;

#define MAX_CH 14
#define SNAP_LEN 2324 // max len of each received packet

#define MAX_X 128
#define MAX_Y 51

esp_err_t event_handler1(void *ctx, system_event_t *event) {
  return ESP_OK;
}

Preferences preferences1;

uint32_t lastDrawTime1;
uint32_t lastButtonTime1;
uint32_t tmpPacketCounter1;
uint32_t pkts11[MAX_X]; // here the packets per second will be saved
uint32_t deauths1 = 0; // deauth frames per second
unsigned int ch1 = 1; // current 802.11 channel
int rssiSum1;

void drawScope(int px, int py, int w, int h) {
  uint16_t trace = ORANGE;

  int div = h / 8;

  float y0 = (cos(10));
  for (int x = 1; x < w; x++) {
    int adr = map(x, 0, w, 0, 1);
    float y = (tan(deauths1) * PI);
    tft.drawLine(px + x, py + (h / 2) + y0, px + x + 1, py + (h / 2) + y, trace);
    y0 = y;
  }
}

double getMultiplicator1() {
  uint32_t maxVal = 1;
  for (int i = 0; i < MAX_X; i++) {
    if (pkts11[i] > maxVal)
      maxVal = pkts11[i];
  }
  if (maxVal > MAX_Y)
    return (double)MAX_Y / (double)maxVal;
  else
    return 1;
}

void wifi_promiscuous1(void *buf, wifi_promiscuous_pkt_type_t type) {
  wifi_promiscuous_pkt_t *pkt = (wifi_promiscuous_pkt_t *)buf;
  wifi_pkt_rx_ctrl_t ctrl = (wifi_pkt_rx_ctrl_t)pkt->rx_ctrl;

  if (type == WIFI_PKT_MGMT && (pkt->payload[0] == 0xA0 || pkt->payload[0] == 0xC0))
    deauths1++;

  if (type == WIFI_PKT_MISC)
    return; // wrong packet type
  if (ctrl.sig_len > SNAP_LEN)
    return; // packet too long

  uint32_t packetLength = ctrl.sig_len;
  if (type == WIFI_PKT_MGMT)
    packetLength -= 4;

  tmpPacketCounter1++;
  rssiSum1 += ctrl.rssi;
}

void setchannel(int newChannel) {
  ch1 = newChannel;
  if (ch1 > MAX_CH || ch1 < 1)
    ch1 = 1;

  preferences1.begin("packetmonitor32", false);
  preferences1.putUInt("channel", ch1);
  preferences1.end();

  esp_wifi_set_promiscuous(false);
  esp_wifi_set_channel(ch1, WIFI_SECOND_CHAN_NONE);
  esp_wifi_set_promiscuous_rx_cb(&wifi_promiscuous1);
  esp_wifi_set_promiscuous(true);
}

void draw1() {
  double multiplicator = getMultiplicator1();
  int len;
  int rssi;

  if (pkts11[MAX_X - 1] > 0)
    rssi = rssiSum1 / (int)pkts11[MAX_X - 1];
  else
    rssi = rssiSum1;

  for (int i = 0; i < MAX_X; i++) {
    len = pkts11[i] * multiplicator;
    if (i < MAX_X - 1)
      pkts11[i] = pkts11[i + 1];
  }
}

void detectorSetup() {
  Serial.begin(115200);

  tft.fillScreen(ST7735_BLACK);

  preferences1.begin("packetmonitor32", false);
  ch1 = preferences1.getUInt("channel", 1);
  preferences1.end();

  nvs_flash_init();
  tcpip_adapter_init();
  wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
  ESP_ERROR_CHECK(esp_event_loop_init(event_handler1, NULL));
  ESP_ERROR_CHECK(esp_wifi_init(&cfg));
  ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
  ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_NULL));
  ESP_ERROR_CHECK(esp_wifi_start());

  esp_wifi_set_channel(ch1, WIFI_SECOND_CHAN_NONE);

  tft.setTextWrap(false);
  tft.setTextSize(1);
  tft.setCursor(2, 2);
  tft.setTextColor(ST7735_BLACK);
  tft.fillRect(0, 0, 128, 10, ORANGE);
  tft.print("ch  |  graph  | value");
}

void detectorLoop() {
  esp_wifi_set_promiscuous_rx_cb(&wifi_promiscuous1);
  esp_wifi_set_promiscuous(true);

  uint32_t currentTime;

  while (true) {
    currentTime = millis();

    if (currentTime - lastDrawTime1 > 1000) {
      lastButtonTime1 = currentTime;

      pkts11[MAX_X - 1] = tmpPacketCounter1;

      draw1();

      Serial.print(ch1);
      Serial.print(":");
      Serial.println(deauths1);

      tmpPacketCounter1 = 0;
      deauths1 = 0;
      rssiSum1 = 0;
    }

    int newChannel = (ch1 % MAX_CH) + 1; // Cycle through channels 1-13

    ch1++;
    setchannel(ch1);
    if (ch1 < 1 || ch1 > 14)
      ch1 = 1;

    delay(1000);

    tft.setTextWrap(false);
    tft.setTextColor(ORANGE);
    tft.setTextSize(1);

    for (int i = 1; i <= 14; i++) {
      tft.setCursor(0, 20 + (i - 1) * 10);
      tft.print(String(i, 10) + ":");
    }

    if (ch1 >= 1 && ch1 <= 14) {
      int y = 10 + (ch1 - 1) * 10;
      tft.fillRect(20, y, 130, 20, ST7735_BLACK);
    }

    if (ch1 >= 1 && ch1 <= 14) {
      int startY = 5 + (ch1 - 1) * 10;
      drawScope(20, startY, 80, 40);
    }

    int lineSpacing = 10;
    int startY = 25;
    int endY = startY;

    for (int i = 0; i < 14; i++) {
      tft.drawLine(20, startY, 100, endY, WHITE);
      startY += lineSpacing;
      endY += lineSpacing;
    }

    tft.setTextSize(1);
    tft.setTextColor(ORANGE);

    for (int i = 1; i <= 14; i++) {
      if (ch1 == i) {
        tft.setCursor(105, 20 + (i - 1) * 10);
        tft.print("[");
        tft.print(deauths1);
        tft.println(" ]");
      }
    }

    for (int i = 1; i <= 14; i++) {
      tft.setCursor(105, 20 + (i - 1) * 10);
      tft.print("[");
      tft.print("  ");
      tft.println("]");
    }
  }
}


detector.cpp

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#ifndef detector_h
#define detector_h

#include <Arduino.h>

#include <Adafruit_GFX.h>   
#include <Adafruit_ST7735.h> 
#include <SPI.h>

void detectorSetup();
void detectorLoop();

#endif


detector.h

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>
#include <Adafruit_NeoPixel.h>

#include "HCScreen.h"
#include "packetmonitor.h"
#include "detector.h"
#include "wifiscanner.h"
#include "beaconspam.h"

#include <SPI.h>

#include "icons.h"

#define TFT_CS 14
#define TFT_RST 33
#define TFT_DC 27

#define BTDOWNDTN 25
#define BTUP 21
#define BTDOWND 22
#define BACK 26

#define MAIN_MENU 0
#define SUB_MENU 1

String main_menu[] = {"1.Packet Monitor", "2.WiFi Analyzer", "3.Beacon Spam", "4.Deauth Detector"};
uint8_t main_menu_cnt = 4;

volatile int whichMenu = 0;
String lastPath = "";

Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);
HCScreen screen = HCScreen(tft);

Adafruit_NeoPixel pixels(1, 4, NEO_GRB + NEO_KHZ800);

String selection = screen.getSelection();
int8_t selectionIndex = screen.getSelectionIndex();

// Function pointers for setup and loop functions
void (*setupFunctions[])(void) = {packetmonitorSetup, wifiscannerSetup, beaconspamSetup, detectorSetup};
void (*loopFunctions[])(void) = {packetmonitorLoop, wifiscannerLoop, beaconspamLoop, detectorLoop};

const uint16_t ORANGE = 0xfbe4;

void setup() {
  Serial.begin(115200);

  pixels.begin();

  tft.initR(INITR_BLACKTAB);
  tft.fillScreen(ST7735_BLACK);
  tft.setRotation(2);

  tft.drawBitmap(12, 5, skull1, 100, 100,ORANGE);

  tft.setTextWrap(false);
  tft.setCursor(10, 110);
  tft.setTextColor(ORANGE);
  tft.setTextSize(1);
  tft.println("ESP32-DIV");
  tft.setCursor(10, 120);
  tft.setTextSize(2);
  tft.println("CiferTech");
  tft.setCursor(45, 140);
  tft.setTextSize(1);
  tft.println("beta version");

    delay(3000);


  tft.fillScreen(ST7735_BLACK);

  screen.setMenu(main_menu, main_menu_cnt);
  screen.setTitle("[ESP32-DIV]");
  screen.setLineHeight(12);

  pinMode(BTDOWNDTN, INPUT_PULLUP);
  pinMode(BTUP, INPUT_PULLUP);
  pinMode(BTDOWND, INPUT_PULLUP);
  pinMode(BACK, INPUT_PULLUP);
}

void loop() {
  String selection = screen.getSelection();
  int8_t selectionIndex = screen.getSelectionIndex();

  if (digitalRead(BTUP) == 0) {
    screen.selectNext();
      pixels.setPixelColor(0, pixels.Color(255, 125, 0));
      pixels.show();     
      pixels.setPixelColor(0, pixels.Color(0, 0, 0));
      pixels.show();    
  }
  if (digitalRead(BTDOWND) == 0) {
    screen.selectPrevious();
      pixels.setPixelColor(0, pixels.Color(255, 125, 0));
      pixels.show();     
      pixels.setPixelColor(0, pixels.Color(0, 0, 0));
      pixels.show();    
  }

  if (digitalRead(BACK) == 0) {
    screen.setMenu(main_menu, main_menu_cnt);
    whichMenu = MAIN_MENU;
  }

  if (digitalRead(BTDOWNDTN) == 0) {
    while (digitalRead(BTDOWNDTN) == 0)
      delay(100);

    if (selection == "Back") {
      screen.setMenu(main_menu, main_menu_cnt);
      whichMenu = MAIN_MENU;
    }

    if (selectionIndex >= 0 && selectionIndex < main_menu_cnt) {
      // Execute the selected setup and loop functions
      setupFunctions[selectionIndex]();
      while (selection == main_menu[selectionIndex]) {
        loopFunctions[selectionIndex]();
        if (digitalRead(BACK) == 0) {
          screen.setMenu(main_menu, main_menu_cnt);
          break;
        }
      }
    }
  }
}


ESP32DIV.ino

HCScreen.cpp

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#ifndef HCScreen_h
#define HCScreen_h

#include <Arduino.h>
#include <Adafruit_ST7735.h>
#include <FS.h>

#define	HC_BLACK   0x000000
#define HC_GRAY    0xC0C0C0
#define	HC_BLUE    0x0000FF
#define	HC_RED     0xFF0000
#define	HC_GREEN   0x00FF00
#define HC_CYAN    0x00FFFF
#define HC_MAGENTA 0xFF00FF
#define HC_YELLOW  0xFFFF00
#define HC_WHITE   0xFFFFFF
#define HC_ORANGE  0xFD7F20

#define HC_NONE 0
#define HC_MENU 1
#define HC_ICONS 2
#define HC_DIRECTORY 3
#define HC_KEYBOARD 4
#define HC_FILE 5
#define HC_STATIC 6


typedef struct { // Data stored for ICON
  unsigned int 	 width;
  unsigned int 	 height;
  unsigned int 	 bytes_per_pixel; /* 2:RGB16, 3:RGB, 4:RGBA */
  unsigned char	 pixel_data[31*31*3+1];
} HCIcon;

class HCScreen {
public:
  //public functions
  HCScreen(Adafruit_ST7735& tft);
//set the font color and background color for standard lines
//default is font in black and background white
//color values are 3 bytes RGB as used in WEB
//colors will be converted to the 16 bit format required
//by tft display
void init();
void showContent(); //refresh display with current content
void setTitle(String title);
void setTitle(String title, uint16_t fontColor, uint16_t bgColor);
void setMenu(String menu[],uint8_t entries);
void showKeyboard(uint8_t shift = 0);
void initKeyboard(String result);
typedef std::function<void(uint8_t mode)> TJoyCallback;
void initJoy(uint8_t xPin, uint8_t yPin, uint8_t btnPin, TJoyCallback fn);
void handleJoy();
void handleDirectory();
void setBaseColor(unsigned long font_color, unsigned long bg_color);
void setSelectionColor(unsigned long font_color, unsigned long bg_color);
void setTitleColor(unsigned long font_color, unsigned long bg_color);
void setGridColor(unsigned long font_color, unsigned long bg_color);
void setKeyboardColor(unsigned long font_color, unsigned long bg_color, unsigned long sel_color);
void selectNext();
void selectPrevious();
void moveRight(); //move selection to right in grid mode
void moveLeft(); //move selection to left in grid mode
String getSelection();
int8_t getSelectionIndex();
String getResult();
void showCodeset();
void setLineHeight(uint8_t height);
void setDirectory(String path, uint8_t SDcs);
String getTitle();
void setTextFile(String path, String fileName);
void initIconGrid();
void initIconGrid(uint8_t x, uint8_t y, uint8_t columns, uint8_t rows);
void showIcon(uint8_t x, uint8_t y, const HCIcon *icon=NULL);
void showIcon(uint8_t index, const HCIcon *icon=NULL);

private:
  //private members
  Adafruit_ST7735& _tft;
  uint8_t _screenLines; //number of lines available
  uint8_t _leftMargin; //space pixels left
  uint8_t _rightMargin; //space pixels right
  uint8_t _topMargin; //space pixels top
  uint8_t _bottomMargin; //space pixels bottom
  uint8_t _lineLength; //characters in a line
  int8_t _selectedLine; //selected line -1 = none
  int8_t _selectedColumn; //xy mode only
  uint16_t _fontColor; //color for font 16 bit tft-format
  uint16_t _bgColor; //color for background 16 bit tft-format
  uint16_t _selFontColor; //color for font in selected line 16 bit tft-format
  uint16_t _selBgColor; //color for background in selected line 16 bit tft-format
  uint16_t _titleFontColor; //color for font in title line 16 bit tft-format
  uint16_t _titleBgColor; //color for background in title line 16 bit tft-format
  uint16_t _gridSelColor; //color for icon selection 16 bit tft-format
  uint16_t _gridBgColor; //color for background of icon grid line 16 bit tft-format
  uint16_t _keyFntColor = 0; //font color for keyboard (black)
  uint16_t _keyBgColor = 0xFFFF; //background for keys (white)
  uint16_t _keySelColor = 0x1F; //selection color for kexboard (blue)
  uint8_t _keyboard = 0; //flag for display is in keyboard mode
  String _keyResult = ""; //entered data
  uint8_t _keyCursor = 0; //Cursor for result input
  uint8_t _showTitle=0; //if 1 title will be displayed
  String _title; //title to be displayed
  String _content[100]; //content to be displayed
  uint8_t _contentLines = 0; //number of lines in content
  uint8_t _startLine; //first line of content to be displayed
  uint8_t _lineHeight  = 8; //height of a line in pixels 8= minimal value
  uint8_t _rows = 4; //rows for icon grid
  uint8_t _columns = 5; //columns for icon grid
  uint8_t _icons = 0; //number of icon_close
  uint8_t _gridMode = 0; //if 1 grid mode is aktive
  uint8_t _gridX = 0; //grid x position
  uint8_t _gridY = 0; //grid y position
  uint8_t _keyX = 0; //keyboard x position
  uint8_t _keyY = 0; //keyboard y position
  uint8_t _keyShift; //keyboard im shift zustand
  uint8_t _joyX; //Pin to read x value from Joystik
  uint8_t _joyY; //Pin to read y value from Joystik
  uint8_t _joyBtn; //pin to get button state from Joystik
  uint8_t _wait; //delay for joystik
  uint8_t _screenMode; //active screen mode
  String _lastPath; //path for text files
  uint8_t _sdCs; //CS pin for sd card reader

  uint16_t convertColor(unsigned long webColor );
  void showLine(uint8_t lin, String txt, uint16_t font, uint16_t bg);
  uint8_t loadDir(fs::FS &fs, String path, uint8_t cnt);
  void showGridSelection(uint16_t color);
  void showKeySelection(uint16_t color);
  void showOneLine(uint8_t lin, uint16_t fnt, uint16_t bg);
  void keyPressed();
  TJoyCallback _callback;
};


#endif


HCScreen.h

icons.h

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#include <Arduino.h> 
#include "packetmonitor.h"

extern Adafruit_ST7735 tft;

arduinoFFT FFT = arduinoFFT();
extern Adafruit_NeoPixel pixels;

#define MAX_CH 14       
#define SNAP_LEN 2324   

#define BUTTON_PIN 22   
#define BACK 26 

#define MAX_X 128
#define MAX_Y 51

const uint16_t GRAY = 303131;
const uint16_t BLUE = 0x001f;
const uint16_t RED = 0xf800;
const uint16_t GREEN = 0x07e0;
const uint16_t BLACK = 0;
const uint16_t YELLOW = RED + GREEN;
const uint16_t CYAN = GREEN + BLUE;
const uint16_t MAGENTA = RED + BLUE;
const uint16_t WHITE = RED + BLUE + GREEN;
const uint16_t ORANGE = 0xfbe4;

esp_err_t event_handler(void* ctx, system_event_t* event) {
  return ESP_OK;
}

Preferences preferences;

const int analogInputPin = 39;
const uint16_t samples = 256; 
const double samplingFrequency = 5000;

double attenuation = 10;

unsigned int sampling_period_us;
unsigned long microseconds;

double vReal[samples];
double vImag[samples];

byte palette_red[128], palette_green[128], palette_blue[128];

bool useSD = false;
bool buttonPressed = false;
bool buttonEnabled = true;
uint32_t lastDrawTime;
uint32_t lastButtonTime;
uint32_t tmpPacketCounter;
uint32_t pkts[MAX_X];       // here the packets per second will be saved
uint32_t deauths = 0;       // deauth frames per second
unsigned int ch = 1;        // current 802.11 channel
int rssiSum;

unsigned int epoch = 0;
unsigned int color_cursor = 2016;

double getMultiplicator() {
  uint32_t maxVal = 1;
  for (int i = 0; i < MAX_X; i++) {
    if (pkts[i] > maxVal) maxVal = pkts[i];
  }
  if (maxVal > MAX_Y) return (double)MAX_Y / (double)maxVal;
  else return 1;
}

void wifi_promiscuous(void* buf, wifi_promiscuous_pkt_type_t type) {
  wifi_promiscuous_pkt_t* pkt = (wifi_promiscuous_pkt_t*)buf;
  wifi_pkt_rx_ctrl_t ctrl = (wifi_pkt_rx_ctrl_t)pkt->rx_ctrl;

  if (type == WIFI_PKT_MGMT && (pkt->payload[0] == 0xA0 || pkt->payload[0] == 0xC0 )) deauths++;

  if (type == WIFI_PKT_MISC) return;            
  if (ctrl.sig_len > SNAP_LEN) return;           
      pixels.setPixelColor(0, pixels.Color(64, 20, 0));
      pixels.show(); 
  uint32_t packetLength = ctrl.sig_len;
  if (type == WIFI_PKT_MGMT) packetLength -= 4;  
  //Serial.print(".");
  tmpPacketCounter++;
  rssiSum += ctrl.rssi;
      pixels.setPixelColor(0, pixels.Color(0, 0, 0));
      pixels.show();     
}

void setChannel(int newChannel) {
  ch = newChannel;
  if (ch > MAX_CH || ch < 1) ch = 1;

  preferences.begin("packetmonitor32", false);
  preferences.putUInt("channel", ch);
  preferences.end();

  esp_wifi_set_promiscuous(false);
  esp_wifi_set_channel(ch, WIFI_SECOND_CHAN_NONE);
  esp_wifi_set_promiscuous_rx_cb(&wifi_promiscuous);
  esp_wifi_set_promiscuous(true);
}


void draw() {
  double multiplicator = getMultiplicator();
  int len;
  int rssi;

  if (pkts[MAX_X - 1] > 0) rssi = rssiSum / (int)pkts[MAX_X - 1];
  else rssi = rssiSum;
}


void do_sampling_FFT() {
   
  microseconds = micros();
  for(int i=0; i < samples; i++) {
      vReal[i] = tmpPacketCounter*300;
      vImag[i] = 1;
      while(micros() - microseconds < sampling_period_us){
        
      }
      microseconds += sampling_period_us;
  }
  
  double mean = 0;
  for (uint16_t i = 0; i < samples; i++)
    mean += vReal[i];
  mean /= samples;
  for (uint16_t i = 0; i < samples; i++)
    vReal[i] -= mean;
    
  microseconds = micros();
  
  FFT.Windowing(vReal, samples, FFT_WIN_TYP_HAMMING, FFT_FORWARD); 
  FFT.Compute(vReal, vImag, samples, FFT_FORWARD); 
  FFT.ComplexToMagnitude(vReal, vImag, samples); 

  unsigned int top_y = 155;
  int max_k = 0;
  for (int j = 0; j < samples >> 1; j++) {
      int k = vReal[j] / attenuation;
      if (k > max_k)
        max_k = k;      
      if (k > 127) k = 127;
      unsigned int color = palette_red[k] << 11 | palette_green[k] << 5 | palette_blue[k]; 
      tft.drawPixel(epoch, top_y - j, color);
  }
  double tattenuation = max_k / 127.0;
  if (tattenuation > attenuation)
    attenuation = tattenuation;

          tft.fillRect(0,0,128,10, ORANGE);
          //tft.fillScreen(ST7735_BLACK);
          tft.setTextWrap(false);
          tft.setCursor(20, 2);
          tft.setTextColor(ST7735_BLACK);
          tft.setTextSize(1);
          tft.print(ch);
            
          tft.setCursor(2, 2);
          tft.setTextColor(ST7735_BLACK);
          tft.print("Ch:");

          //tft.fillRect(50,0,15,15, ST7735_BLACK);
          tft.setTextWrap(true);
          tft.setCursor(80, 2);
          tft.setTextColor(ST7735_BLACK);
          tft.setTextSize(1);
          tft.print(tmpPacketCounter);

          tft.setCursor(50, 2);
          tft.setTextColor(ST7735_BLACK);
          tft.print("Pkts:");
 
          delay(10);
}



void packetmonitorSetup(){
  
   Serial.begin(115200);

   pinMode(BACK, INPUT_PULLUP);
     
   //tft.initR(INITR_BLACKTAB);
  // tft.setRotation(0);
   tft.fillScreen(ST7735_BLACK);
      
  sampling_period_us = round(1000000*(1.0/samplingFrequency));

  for (int i = 0; i < 32; i++) {
    palette_red[i] = i / 2;
    palette_green[i] = 0;
    palette_blue[i] = i;
  }
  for (int i = 32; i < 64; i++) {
    palette_red[i] = i / 2;
    palette_green[i] = 0;
    palette_blue[i] = 63 - i;
  }
  for (int i = 64; i < 96; i++) {
    palette_red[i] = 31;
    palette_green[i] = (i - 64) * 2;
    palette_blue[i] = 0;        
  }
  for (int i = 96; i < 128; i++) {
    palette_red[i] = 31;
    palette_green[i] = 63;
    palette_blue[i] = i - 96;        
  }
   
  sampling_period_us = round(1000000*(1.0/samplingFrequency));

  preferences.begin("packetmonitor32", false);
  ch = preferences.getUInt("channel", 1);
  preferences.end();

  //nvs_flash_init();
  tcpip_adapter_init();
  wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
  ESP_ERROR_CHECK(esp_event_loop_init(event_handler, NULL));
  ESP_ERROR_CHECK(esp_wifi_init(&cfg));
  //ESP_ERROR_CHECK(esp_wifi_set_country(WIFI_COUNTRY_EU));
  //ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
  ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_NULL));
  ESP_ERROR_CHECK(esp_wifi_start());

  esp_wifi_set_channel(ch, WIFI_SECOND_CHAN_NONE);

  pinMode(BUTTON_PIN, INPUT_PULLUP);

  esp_wifi_set_promiscuous_rx_cb(&wifi_promiscuous);
  esp_wifi_set_promiscuous(true);
}


void packetmonitorLoop(){
 
  tft.drawPixel(epoch, 0, color_cursor);
  do_sampling_FFT();
  delay(10);
  
  tft.drawPixel(epoch, 0, 0);
  epoch++;
  if (epoch >= tft.width())
    epoch = 0;



    if (digitalRead(BUTTON_PIN) == LOW) {
      if (buttonEnabled) {
        if (!buttonPressed) {
          buttonPressed = true;
        }
      }
    
      if (buttonPressed) {
        setChannel(ch + 1);
                 
      }
      buttonPressed = false;
      buttonEnabled = true;
    }
   
      pkts[127] = tmpPacketCounter;

      Serial.println((String)pkts[MAX_X - 1]);

      tmpPacketCounter = 0;
      deauths = 0;
      rssiSum = 0;
    
    
    if (Serial.available()) {
      ch = Serial.readString().toInt();
      if (ch < 1 || ch > 14) ch = 1;
      setChannel(ch);
    }
}


packetmonitor.cpp

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#ifndef packetmonitor_H
#define packetmonitor_H

#include "arduinoFFT.h"
#include <Adafruit_GFX.h>   
#include <Adafruit_ST7735.h> 
#include <Adafruit_NeoPixel.h>
#include <SPI.h>

#include "esp_wifi.h"
#include "esp_wifi_types.h"
#include "esp_system.h"
#include "esp_event.h"
#include "esp_event_loop.h"
#include "nvs_flash.h"
#include <stdio.h>
#include <string>
#include <cstddef>
#include <Wire.h>
#include <Preferences.h>

void packetmonitorSetup();
void packetmonitorLoop();

#endif


packetmonitor.h

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#include <Arduino.h> 
#include "WiFi.h"
#include "wifiscanner.h"

extern Adafruit_ST7735 tft;


const uint16_t GRAY = 303131;
const uint16_t BLUE = 0x001f;
const uint16_t RED = 0xf800;
const uint16_t GREEN = 0x07e0;
const uint16_t BLACK = 0;
const uint16_t YELLOW = RED + GREEN;
const uint16_t CYAN = GREEN + BLUE;
const uint16_t MAGENTA = RED + BLUE;
const uint16_t WHITE = RED + BLUE + GREEN;
const uint16_t ORANGE = 0xfbe4;

bool buttonPress = false;
bool buttonEnable = true;
unsigned int channel = 1;

#define BUTTON_PIN 22 


void wifiscannerSetup(){

  tft.fillScreen(ST7735_BLACK);

  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);

  pinMode(BUTTON_PIN, INPUT_PULLUP);


  tft.setTextColor(ST7735_WHITE);
  tft.setTextSize(1);
  tft.setCursor(0, 15);
  tft.println("/ | SSID | RSSI | CH ");
}


void wifiscannerLoop(){

     tft.fillRect(0,0,128,10, ORANGE);

     tft.setTextWrap(false);
     tft.setCursor(100, 2);
     tft.setTextColor(ST7735_BLACK);
     tft.setTextSize(1);
     tft.print("");
     tft.print("1-14");
     tft.println("");
            
     tft.setCursor(2, 2);
     tft.setTextColor(ST7735_BLACK);
     tft.print("scanning channel");


    if (digitalRead(BUTTON_PIN) == LOW) {
      if (channel < 1 || channel > 14) channel = 1;
        channel++;  
        delay(100);              
      }
      
   
  int n = WiFi.scanNetworks();
  
     tft.fillRect(0,30,128,160, ST7735_BLACK);
     
     tft.setTextColor(ORANGE);
     tft.setTextSize(1);


    for (int i = 1; i <= 14; i++) {
      tft.setCursor(0, 30 + (i - 1) * 10);
      tft.print(String(i, 10) + ":");
    }


    
    int maxLength = 9; // Set the maximum length you want to display
    
    for (int i = 0; i < 13; i++) {
        tft.setCursor(20, 30 + i * 10); // Adjust the starting y-coordinate
        String ssid = WiFi.SSID(i);
        String truncatedSSID = ssid.substring(0, maxLength);
        
        bool isOpen = WiFi.encryptionType(i) == WIFI_AUTH_OPEN;
    
        if (isOpen) {
            tft.setTextColor(GREEN); // Set the text color to green for open networks
        } else {
            tft.setTextColor(ORANGE); // Set the text color to white for other networks
        }
    
        tft.print(truncatedSSID.c_str());
    
        // Reset the text color to white for the next iteration
        tft.setTextColor(ORANGE);
    }


    for (int i = 0; i < 13; i++) {
        tft.setCursor(80, 30 + i * 10); // Adjust the starting y-coordinate
        tft.println(WiFi.RSSI(i));
    }


    for (int i = 0; i < 13; i++) {
        tft.setCursor(110, 30 + i * 10); // Adjust the starting y-coordinate
        tft.println(WiFi.channel(i));
    }

         
   WiFi.scanDelete();
   
}


wifiscanner.cpp

/* ____________________________
   This software is licensed under the MIT License:
   https://github.com/cifertech/ESP32-DIV
   ________________________________________ */

#ifndef wifiscanner_h
#define wifiscanner_h

#include <Arduino.h>

#include <Adafruit_GFX.h>   
#include <Adafruit_ST7735.h> 
#include <SPI.h>

void wifiscannerSetup();
void wifiscannerLoop();

#endif


wifiscanner.h

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

# Automatically added based on includes:
Adafruit GFX Library
Adafruit NeoPixel

Adafruit GFX Library
Adafruit ST7735 and ST7789 Library
Adafruit STMPE610
Adafruit NeoPixel
Adafruit SSD1331 OLED Driver Library for Arduino
Adafruit ILI9341