eessppeelllloo/esp8266_deauther
1
0
Fork 0
mirror of https://github.com/SpacehuhnTech/esp8266_deauther.git synced 2025-12-22 14:40:05 +01:00
Code Issues Packages Projects Releases Wiki Activity

Refactored LED class

Browse Source 
No more sub classes for faster compile times.
Libraries like Neopixel are only included if needed and there are less variables in the RAM.
This commit is contained in:
Stefan Kremser
2019-05-08 15:47:41 +02:00
parent 34915e2138
commit 4252b4f2f6
3 changed files with 1384 additions and 1485 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2347
esp8266_deauther/CLI.cpp
View File

File diff suppressed because it is too large Load Diff

289
esp8266_deauther/LED.cpp
View File

@@ -1,205 +1,84 @@
#include "LED.h" #include "LED.h"
LED::LED() {} // Strings used in printColor and tempDisable
#include "language.h"
LED::~LED() {
if (led) delete led; // For Update()
} #include "Settings.h"
#include "Attack.h"
void LED::setup() { #include "Scan.h"
#if defined(DIGITAL_LED)
led = new DigitalLED(LED_PIN_R, LED_PIN_G, LED_PIN_B, LED_ANODE); extern Settings settings;
led->setup(); extern Attack attack;
#elif defined(RGB_LED) extern Scan scan;
led = new LED::AnalogRGBLED(LED_PIN_R, LED_PIN_G, LED_PIN_B, LED_MODE_BRIGHTNESS, LED_ANODE);
led->setup(); void LED::update() {
#elif defined(NEOPIXEL_LED) if (!tempEnabled) return;
led = new LED::NeopixelLED(LED_NEOPIXEL_NUM, LED_NEOPIXEL_PIN, LED_MODE_BRIGHTNESS);
led->setup(); if (!settings.getLedEnabled() && tempEnabled) {
#endif // if defined(DIGITAL_LED) tempDisable();
} }
void LED::update() { if (scan.isScanning() && (scan.deauths < settings.getMinDeauths())) {
if (!tempEnabled || !led) return; setMode(SCAN);
} else if (scan.deauths >= settings.getMinDeauths()) {
if (!settings.getLedEnabled() && tempEnabled) tempDisable(); setMode(DEAUTH);
} else if (attack.isRunning()) {
if (scan.isScanning() && (scan.deauths < settings.getMinDeauths())) setMode(LED_MODE::SCAN, false); setMode(ATTACK);
else if (scan.deauths >= settings.getMinDeauths()) setMode(LED_MODE::DEAUTH, false); } else {
else if (attack.isRunning()) setMode(LED_MODE::ATTACK, false); setMode(IDLE);
else setMode(LED_MODE::IDLE, false); }
} }
void LED::setMode(uint8_t mode, bool force) { void LED::printColor(uint8_t r, uint8_t g, uint8_t b) {
if (!led) return; char s[30];
if ((mode != LED::mode) || force) { sprintf_P(s, L_OUTPUT, r, g, b);
LED::mode = mode; prnt(String(s));
}
switch (mode) {
case LED_MODE::OFF: void LED::setMode(LED_MODE mode, bool force) {
led->setColor(0, 0, 0); if ((mode != this->mode) || force) {
break; this->mode = mode;
case LED_MODE::SCAN: switch (mode) {
led->setColor(0, 0, 255); case OFF:
break; setColor(0, 0, 0);
break;
case LED_MODE::ATTACK:
led->setColor(255, 255, 0); case SCAN:
break; setColor(0, 0, 255);
break;
case LED_MODE::DEAUTH:
led->setColor(255, 0, 0); case ATTACK:
break; setColor(255, 0, 0);
break;
case LED_MODE::IDLE:
led->setColor(0, 255, 0); case DEAUTH:
break; setColor(255, 0, 0);
} break;
}
} case IDLE:
setColor(0, 255, 0);
void LED::setColor(uint8_t r, uint8_t g, uint8_t b, bool output) { break;
// debug output }
if (output) { }
char s[30]; }
sprintf_P(s, L_OUTPUT, r, g, b);
prnt(String(s)); void LED::setBrightness(uint8_t brightness) {
} this->brightness = brightness % 100;
}
led->setColor(r, g, b);
} void LED::tempEnable() {
tempEnabled = true;
void LED::setColor(uint8_t r, uint8_t g, uint8_t b, uint8_t brightness, bool output) { prntln(L_ENABLED);
led->setBrightness(brightness); }
setColor(r, g, b, output);
} void LED::tempDisable() {
tempEnabled = false;
void LED::tempEnable() { prntln(L_DISABLED);
tempEnabled = true; }
prntln(L_ENABLED);
} bool LED::getTempEnabled() {
return tempEnabled;
void LED::tempDisable() { }
tempEnabled = false;
prntln(L_DISABLED);
}
bool LED::getTempEnabled() {
return tempEnabled;
}
#ifdef DIGITAL_LED
// ===== DigitalLED ===== //
LED::DigitalLED::DigitalLED(uint8_t rPin, uint8_t gPin, uint8_t bPin, bool anode) {
LED::DigitalLED::anode = anode;
LED::DigitalLED::rPin = rPin;
LED::DigitalLED::gPin = gPin;
LED::DigitalLED::bPin = bPin;
}
LED::DigitalLED::~DigitalLED() {}
void LED::DigitalLED::setup() {
if (rPin < 255) pinMode(rPin, OUTPUT);
if (gPin < 255) pinMode(gPin, OUTPUT);
if (bPin < 255) pinMode(bPin, OUTPUT);
}
void LED::DigitalLED::setColor(uint8_t r, uint8_t g, uint8_t b) {
if (anode) {
if (rPin < 255) digitalWrite(rPin, r > 0);
if (gPin < 255) digitalWrite(gPin, g > 0);
if (bPin < 255) digitalWrite(bPin, b > 0);
} else {
if (rPin < 255) digitalWrite(rPin, r == 0);
if (gPin < 255) digitalWrite(gPin, g == 0);
if (bPin < 255) digitalWrite(bPin, b == 0);
}
}
void LED::DigitalLED::setBrightness(uint8_t brightness) {}
#endif
#ifdef RGB_LED
// ===== AnalogRGBLED ===== //
LED::AnalogRGBLED::AnalogRGBLED(uint8_t rPin, uint8_t gPin, uint8_t bPin, uint8_t brightness, bool anode) {
LED::AnalogRGBLED::anode = anode;
LED::AnalogRGBLED::rPin = rPin;
LED::AnalogRGBLED::gPin = gPin;
LED::AnalogRGBLED::bPin = bPin;
setBrightness(brightness);
}
LED::AnalogRGBLED::~AnalogRGBLED() {}
void LED::AnalogRGBLED::setup() {
analogWriteRange(0xff);
if (rPin < 255) pinMode(rPin, OUTPUT);
if (gPin < 255) pinMode(gPin, OUTPUT);
if (bPin < 255) pinMode(bPin, OUTPUT);
}
void LED::AnalogRGBLED::setColor(uint8_t r, uint8_t g, uint8_t b) {
if ((r > 0) && (brightness < 100)) r = r * brightness / 100;
if ((g > 0) && (brightness < 100)) g = g * brightness / 100;
if ((b > 0) && (brightness < 100)) b = b * brightness / 100;
if (anode) {
r = 255 - r;
g = 255 - g;
b = 255 - b;
}
analogWrite(rPin, r);
analogWrite(gPin, g);
analogWrite(bPin, b);
}
void LED::AnalogRGBLED::setBrightness(uint8_t brightness) {
if (brightness > 100) brightness = 100;
LED::AnalogRGBLED::brightness = brightness;
}
#endif
#ifdef NEOPIXEL_LED
// ===== NeopixelLED ===== //
LED::NeopixelLED::NeopixelLED(int num, uint8_t dataPin, uint8_t brightness) {
strip = new Adafruit_NeoPixel(num, dataPin, LED_NEOPIXEL_MODE);
setBrightness(brightness);
}
LED::NeopixelLED::~NeopixelLED() {
delete strip;
}
void LED::NeopixelLED::setup() {
strip->begin();
strip->show();
}
void LED::NeopixelLED::setColor(uint8_t r, uint8_t g, uint8_t b) {
int num = strip->numPixels();
for (uint16_t i = 0; i < num; i++) strip->setPixelColor(i, strip->Color(r, g, b));
strip->show();
}
void LED::NeopixelLED::setBrightness(uint8_t brightness) {
if (brightness > 100) brightness = 100;
strip->setBrightness(brightness);
}
#endif

233
esp8266_deauther/LED.h
View File

@@ -1,107 +1,126 @@
#ifndef LED_h #ifndef LED_h
#define LED_h #define LED_h
#include "Arduino.h" #include "Arduino.h" // digitalWrite, analogWrite, pinMode
extern "C" { #include "A_config.h" // Config for LEDs
#include "user_interface.h"
} // Inlcude libraries for Neopixel or MY92xx if used
#include "language.h" #if defined(NEOPIXEL_LED)
#include "A_config.h" #include <Adafruit_NeoPixel.h>
#include "Settings.h" #elif defined(MY92)
#include "Attack.h" #include <my92xx.h>
#include "Scan.h" #endif // if defined(NEOPIXEL_LED)
#include <Adafruit_NeoPixel.h> enum LED_MODE {
OFF = 0,
extern Settings settings; SCAN = 1,
extern Attack attack; ATTACK = 2,
extern Scan scan; DEAUTH = 3,
extern Stations stations; IDLE = 4
};
class LED {
public: class LED {
enum LED_MODE { OFF = 0, SCAN = 1, ATTACK = 2, DEAUTH = 3, IDLE = 4 }; private:
bool tempEnabled = true;
LED(); LED_MODE mode = OFF;
~LED();
uint8_t brightness = 100;
void setup();
void update(); #if defined(NEOPIXEL_LED)
Adafruit_NeoPixel strip(LED_NEOPIXEL_NUM, LED_NEOPIXEL_PIN, LED_NEOPIXEL_MODE);
void setMode(uint8_t mode, bool force); #elif defined(MY92)
my92xx myled(MY92_MODEL, MY92_NUM, MY92_DATA, MY92_CLK, MY92XX_COMMAND_DEFAULT);
void setColor(uint8_t r, uint8_t g, uint8_t b, bool output); #endif // if defined(NEOPIXEL_LED)
void setColor(uint8_t r, uint8_t g, uint8_t b, uint8_t brightness, bool output);
public:
void tempEnable(); void setup() {
void tempDisable(); analogWriteRange(0xff);
bool getTempEnabled();
#if defined(LED_MODE_BRIGHTNESS)
private: brightness = LED_MODE_BRIGHTNESS;
class StatusLED { #endif // if defined(LED_MODE_BRIGHTNESS)
public:
virtual ~StatusLED() = default; #if defined(DIGITAL_LED) || defined(RGB_LED)
if (LED_PIN_R < 255) pinMode(LED_PIN_R, OUTPUT);
virtual void setup() = 0; if (LED_PIN_G < 255) pinMode(LED_PIN_G, OUTPUT);
if (LED_PIN_B < 255) pinMode(LED_PIN_B, OUTPUT);
virtual void setColor(uint8_t r, uint8_t g, uint8_t b) = 0; #elif defined(NEOPIXEL_LED)
virtual void setBrightness(uint8_t brightness) = 0; strip.begin();
}; strip.setBrightness(brightness);
#ifdef DIGITAL_LED strip.show();
class DigitalLED : public StatusLED { #elif defined(MY9291)
public: myled.setChannel(MY92_CH_R, 0);
DigitalLED(uint8_t rPin, uint8_t gPin, uint8_t bPin, bool anode); myled.setChannel(MY92_CH_G, 0);
~DigitalLED(); myled.setChannel(MY92_CH_B, 0);
myled->setChannel(MY92_CH_BRIGHTNESS, brightness);
void setup(); myled->setChannel(3, 100);
void setColor(uint8_t r, uint8_t g, uint8_t b); myled.setState(true);
void setBrightness(uint8_t brightness); myled.update();
void setMode(uint8_t mode, bool force); #endif // if defined(DIGITAL_LED) || defined(RGB_LED)
}
private:
bool anode = true; void update();
uint8_t rPin = 255;
uint8_t gPin = 255; void printColor(uint8_t r, uint8_t g, uint8_t b);
uint8_t bPin = 255;
}; void setMode(LED_MODE mode, bool force = false);
#endif void setBrightness(uint8_t brightness);
#ifdef RGB_LED
class AnalogRGBLED : public StatusLED { void setColor(uint8_t r, uint8_t g, uint8_t b, uint8_t brightness, bool output = false) {
public: setBrightness(brightness);
AnalogRGBLED(uint8_t rPin, uint8_t gPin, uint8_t bPin, uint8_t brightness, bool anode); setColor(r, g, b, output);
~AnalogRGBLED(); }
void setup(); void setColor(uint8_t r, uint8_t g, uint8_t b, bool output = false) {
void setColor(uint8_t r, uint8_t g, uint8_t b); if (output) printColor(r, g, b);
void setBrightness(uint8_t brightness);
void setMode(uint8_t mode, bool force); #if defined(DIGITAL_LED)
if (LED_ANODE) {
private: if (LED_PIN_R < 255) digitalWrite(LED_PIN_R, r > 0);
bool anode = true; if (LED_PIN_G < 255) digitalWrite(LED_PIN_G, g > 0);
uint8_t rPin = 255; if (LED_PIN_B < 255) digitalWrite(LED_PIN_B, b > 0);
uint8_t gPin = 255; } else {
uint8_t bPin = 255; if (LED_PIN_R < 255) digitalWrite(LED_PIN_R, r == 0);
uint8_t brightness = 0; if (LED_PIN_G < 255) digitalWrite(LED_PIN_G, g == 0);
}; if (LED_PIN_B < 255) digitalWrite(LED_PIN_B, b == 0);
#endif }
#ifdef NEOPIXEL_LED #elif defined(RGB_LED)
class NeopixelLED : public StatusLED { if ((r > 0) && (brightness > 0)) r = r * brightness / 100;
public: if ((g > 0) && (brightness > 0)) g = g * brightness / 100;
NeopixelLED(int num, uint8_t dataPin, uint8_t brightness); if ((b > 0) && (brightness > 0)) b = b * brightness / 100;
~NeopixelLED();
if (LED_ANODE) {
void setup(); r = 255 - r;
void setColor(uint8_t r, uint8_t g, uint8_t b); g = 255 - g;
void setBrightness(uint8_t brightness); b = 255 - b;
void setMode(uint8_t mode, bool force); }
private: analogWrite(LED_PIN_R, r);
Adafruit_NeoPixel* strip; analogWrite(LED_PIN_G, g);
}; analogWrite(LED_PIN_B, b);
#endif #elif defined(NEOPIXEL_LED)
bool tempEnabled = true; if ((r > 0) && (brightness > 0)) r = r * brightness / 100;
uint8_t mode = LED_MODE::OFF; if ((g > 0) && (brightness > 0)) g = g * brightness / 100;
StatusLED* led = NULL; if ((b > 0) && (brightness > 0)) b = b * brightness / 100;
};
for (size_t i = 0; i < LED_NEOPIXEL_NUM; i++) {
#endif // ifndef LED_h strip.setPixelColor(i, r, g, b);
}
strip.show();
#elif defined(MY9291)
myled->setChannel(MY92_CH_R, r);
myled->setChannel(MY92_CH_G, g);
myled->setChannel(MY92_CH_B, b);
myled->setChannel(MY92_CH_BRIGHTNESS, brightness);
myled->setState(true);
myled->update();
#endif // if defined(DIGITAL_LED)
}
void tempEnable();
void tempDisable();
bool getTempEnabled();
};
#endif // ifndef LED_h