HackBox 15-en-1 – L’Ultime Couteau Suisse Pro 🛠️⚡️

1️⃣ C’est Quoi, la HackBox ?

La HackBox 15-en-1 est un gadget que tu vas construire, comme un jouet high-tech. Elle peut capter des signaux radio, générer du bruit blanc, déclencher un court-circuit sécurisé, ou imiter un clavier USB. On utilise une breadboard (une plaque pour brancher des fils) ou un carton pour les bricoleurs. Pas besoin d’être un pro, on va :

• Acheter des pièces (~55 € sur Amazon ou AliExpress).
• Connecter avec des fils, sans complications.
• Programmer l’ESP32 (le cerveau) pour tout contrôler.
• Finir avec un boîtier stylé (optionnel).

Tout est lab only : teste chez toi, sur ton matos, sans embêter personne. Prêt à créer une bête cybernétique ? 🛠️⚡️

2️⃣ Règles Éthiques

Ce projet est pour apprendre. Utilise la HackBox chez toi, sur ton propre matos (ex. : une vieille télécommande). Dehors, c’est illégal :

• France : Article 323-1 du Code pénal (7 ans, 100 000 €).
• Europe : Interdiction de bloquer des signaux ou d’interférer.

Promesse d’Apache

Teste sur tes appareils en lab. Platon-y et pctamalou.fr ne sont pas responsables si tu fais n’imp’ !

Sécurité

• Fusible : Protège le circuit.
• Attention : Débranche la batterie avant de connecter. Vérifie avec un multimètre.
• Court-circuit : Résistance 10Ω et fusible pour sécurité.

3️⃣ Liste des Pièces

Voici ce qu’il te faut (~55 €). Cherche sur Amazon, AliExpress, ou Mouser :

Total : ~55 €. Conseil : Prends un kit breadboard avec fils sur Amazon.

4️⃣ Fonctions Cool

Ta HackBox peut faire :

1. LED Clignotante : Animation cyclique RGB.
2. Buzzer d’Alerte : 3 bips séquentiels.
3. Testeur de Continuité : Vérifie connexions via photorésistance.
4. Jammer IR : Bloque capteurs (lab only).
5. Générateur Carré : Signaux de test via NE555.
6. Capteur Toucher : Détecte contact physique.
7. Testeur Tension : Mesure 3-9V avec diviseur.
8. Émetteur Sonore : Sons à fréquence variable.
9. Détecteur Magnétique : Repère aimants via Reed Switch.
10. Court-Circuit Sécurisé : Déclenche un court-circuit contrôlé (lab only).
11. Amplificateur Signal : Booste signaux RF.
12. Détecteur Lumière Pulsée : Log lumière toutes les minutes.
13. Testeur Diodes : Vérifie diodes Si.
14. Générateur Bruit Blanc : Génère bruit audio via DAC.
15. Sniffer RF : Signaux 433 MHz avec logs.
16. Sniffer Wi-Fi/BLE : Réseaux Wi-Fi/Bluetooth avec logs.
17. Décodage Codes Roulants : Télécommandes (lab only).
18. Jammer Wideband (2.4 GHz) : Bloque signaux 2.4 GHz (lab only).

5️⃣ Dessins des Circuits

Ces schémas montrent comment brancher sur la breadboard. Chaque "—" est un fil jumper.

Sniffer RF (CC1101) :

+5V---[Fusible 0.5A]---[S1:Interrupteur]---[CC1101 VCC]
 |                                             |
[Antenne PCB]---[CC1101 RF]---[Q1:2N3904 Base]---[R1 (10kΩ)]---[ESP32 Patte 5]
 |                                             |
 +---[C1:1µF]---[Q1:Collector]---[LED Rouge]---[R2 (470Ω)]---GND
 |                                             |
 +--------------------------------------------[Q1:Emitter]---GND
                

OLED + LED RGB :

+3.3V---[Fusible 0.5A]---[S2:Interrupteur]---[ESP32 3V3]
 |                            |
 +---[R3 (1kΩ)]---[Patte 22]---[OLED SDA]
 |                            |
 +---[R4 (1kΩ)]---[Patte 21]---[OLED SCL]
 |                            |
 +---[R5 (470Ω)]---[Patte 18]---[LED RGB R]
 |                            |
 +---[R6 (470Ω)]---[Patte 19]---[LED RGB G]
 |                            |
 +---[R7 (470Ω)]---[Patte 23]---[LED RGB B]
                

Jammer IR :

+5V---[S3:Interrupteur]---[NE555 Pin 8]
 |                        |
 +---[R8 (1kΩ)]---[Pin 3]---[LED IR]---[R9 (470Ω)]---GND
                

Buzzer :

+5V---[S4:Interrupteur]---[Buzzer +]
 |                        |
 +-----------------------[Buzzer -]---GND
                

Détecteur Magnétique (Reed Switch) :

+3.3V---[R10 (10kΩ)]---[ESP32 Patte 13]---[Reed Switch]---GND
                

Testeur Tension (Diviseur) :

[Entrée Tension]---[R11 (10kΩ)]---[ESP32 Patte 35]---[R12 (10kΩ)]---GND
                

Testeur Diodes :

+5V---[R13 (1kΩ)]---[ESP32 Patte 32]---[Diode à tester]---[Photorésistance]---GND
                

Court-Circuit Sécurisé :

+5V---[S5:Interrupteur]---[Fusible 0.5A]---[R14 (10Ω)]---[ESP32 Patte 27]---GND
                

Générateur Bruit Blanc (MCP4725) :

+3.3V---[S6:Interrupteur]---[MCP4725 VCC]
 |                           |
 +---[R15 (1kΩ)]---[Patte 22]---[MCP4725 SDA]
 |                           |
 +---[R16 (1kΩ)]---[Patte 21]---[MCP4725 SCL]
 |                           |
 +---[C2:1µF]---[MCP4725 OUT]---[Buzzer +]---GND
                

Jammer Wideband (2.4 GHz) :

+5V---[S7:Interrupteur]---[NE555 Pin 8]
 |                        |
 +---[R17 (1kΩ)]---[Pin 3]---[ESP32 Patte 14]---[Antenne 2.4 GHz]---GND
                

6️⃣ Comment Connecter

On construit sur une breadboard ou un carton. Temps : ~6-8h.

Étape 1 : Préparation

1. Breadboard : Prends une breadboard (~3 € sur Amazon). Les trous d’une ligne sont connectés (ex. : ligne 1).
2. Carton : Carton rigide (20x15 cm), colle les pièces avec scotch double-face, relie avec fils.
3. Outils :
   • Fer à souder (30W, ~10 € on Amazon).
   • Étain (~5 €).
   • Multimètre (~10 €).
   • Pince, loupe, ventilateur.
   • Fils jumper (~3 €).
4. Sécurité : Table propre, lunettes, ventilation.

Étape 2 : Connexions

Conseil visuel : Fils rouges (+), noirs (GND), autres pour signaux.

1. ESP32 :
   • Quoi : ESP32-WROOM-32, puce avec 38 pattes.
   • Où : Breadboard (lignes 1-20) or collé sur carton.
   • Comment :
     • Patte 3 (VCC) à +3.3V (ligne +).
     • Patte 2 (GND) à GND (ligne -).
     • Garde pattes 5, 13, 14, 21, 22, 27, 32, 35 libres.
   • Test : Multimètre en mode bip : VCC et GND ne bippent pas.
2. CC1101 :
   • Quoi : CC1101, puce carrée.
   • Où : Ligne 30.
   • Comment :
     • VCC à +5V, GND à GND.
     • RF à antenne PCB (fil ou soudure).
     • R1 (10kΩ) entre patte 5 ESP32 et base Q1.
     • Q1, LED Rouge, R2 (470Ω) comme schéma.
   • Test : Batterie branchée, appuie S1, LED Rouge clignote.
3. OLED :
   • Quoi : OLED 0.96" I2C, 4 pins.
   • Où : Breadboard.
   • Comment :
     • VCC à +3.3V, GND à GND.
     • SDA à patte 22 via R3 (1kΩ).
     • SCL à patte 21 via R4 (1kΩ).
   • Test : Après programmation, OLED affiche "HackBox".
4. LED RGB :
   • Quoi : LED RGB, 4 pattes.
   • Où : Breadboard.
   • Comment :
     • R à patte 18 via R5 (470Ω).
     • G à patte 19 via R6 (470Ω).
     • B à patte 23 via R7 (470Ω).
     • GND à GND.
   • Test : Après programmation, LED change de couleur.
5. Alimentation :
   • Quoi : Batterie LiPo 3.7V, DC-DC.
   • Où : Breadboard ou carton.
   • Comment :
     • Batterie à DC-DC (+ et -).
     • Fusible 0.5A entre batterie et +5V.
     • DC-DC : 5V à +5V, 3.3V à +3.3V, GND à GND.
   • Test : Multimètre : 5V sur +5V, 3.3V sur +3.3V.
6. Reed Switch (Détecteur Magnétique) :
   • Quoi : Reed Switch pour détecter aimants.
   • Où : Breadboard.
   • Comment :
     • Une patte à GND.
     • Autre patte à patte 13 via R10 (10kΩ).
     • +3.3V à patte 13 via R10.
   • Test : Aimant proche, OLED affiche "Aimant détecté!".
7. Testeur Tension :
   • Quoi : Diviseur de tension (R11, R12).
   • Où : Breadboard.
   • Comment :
     • R11 (10kΩ) entre entrée tension et patte 35.
     • R12 (10kΩ) entre patte 35 et GND.
   • Test : Après programmation, OLED affiche tension.
8. Testeur Diodes :
   • Quoi : Circuit avec photorésistance.
   • Où : Breadboard.
   • Comment :
     • R13 (1kΩ) entre +5V et patte 32.
     • Diode à tester entre patte 32 et photorésistance.
     • Photorésistance à GND.
   • Test : Après programmation, OLED affiche état diode.
9. Court-Circuit Sécurisé :
   • Quoi : Circuit avec faible résistance.
   • Où : Breadboard.
   • Comment :
     • S5 à +5V via fusible 0.5A.
     • R14 (10Ω) entre S5 et patte 27.
     • Patte 27 à GND.
   • Test : Appuie S5, OLED affiche "Court-circuit déclenché".
10. Générateur Bruit Blanc (MCP4725) :
    • Quoi : DAC MCP4725 pour bruit audio.
    • Où : Breadboard.
    • Comment :
      • VCC à +3.3V via S6, GND à GND.
      • SDA à patte 22 via R15 (1kΩ).
      • SCL à patte 21 via R16 (1kΩ).
      • OUT à Buzzer via C2 (1µF).
    • Test : Après programmation, buzzer émet bruit blanc.
11. Jammer Wideband (2.4 GHz) :
    • Quoi : NE555 pour signal 2.4 GHz.
    • Où : Breadboard.
    • Comment :
      • S7 à +5V, GND à GND.
      • R17 (1kΩ) entre NE555 Pin 3 et patte 14.
      • Antenne 2.4 GHz à patte 14.
    • Test : Appuie S7, OLED affiche "Jammer 2.4 GHz actif".
12. Autres :
    • Quoi : NE555, buzzer, photorésistance, microSD, etc.
    • Comment :
      • NE555 pour jammer IR (schéma).
      • Buzzer à +5V/GND via S4.
      • MicroSD à patte 15 (SPI).
      • JST pour NFC/GPS.
    • Test : Multimètre : connexions OK.

Étape 3 : Vérification

Avant programmation :

• Pas de fils croisés.
• Multimètre : VCC/GND ne bippent pas.

Étape 4 : Boîtier

Après tests, mets dans un boîtier (10x15x5 cm) :

• Simple : Boîte plastique (~2 € on Amazon).
• Pro : Boîtier 3D noir mat (fablab, ~5 €).
• Fixe avec scotch double-face.

7️⃣ Améliorations Pro

Breadboard

Fils rouges (+), noirs (GND), étiquettes.

Veille

ESP32 dort (~10µA). S1 réveille.

Sécurité

PIN 1234, 3 erreurs = blocage.

Logs

Wi-Fi/RF/Bruit sur microSD (CSV).

Guides

OLED affiche astuces (ex. : "S1 pour RF").

8️⃣ Bonus Secrets (Lab Only)

⚠️ Pour apprendre, pas dehors !

• Wi-Fi/BLE : Liste réseaux.
• Codes Roulants : Analyse télécommandes.
• Backdoor USB : Clavier HID.
• Jammer Wideband : 2.4 GHz (lab only).
• Court-Circuit : Sécurisé avec fusible (lab only).
• NFC/GPS : Modules JST.

9️⃣ Protections

• Ouverture : Reed switch + buzzer.
• Faraday : Boîtier métallique.
• Court-circuit : Fusible 0.5A et R14 (10Ω) pour sécurité.

10️⃣ Tests

Sniffer RF

1. Charge batterie (USB-C, 2h).
2. Appuie S1.
3. Télécommande 433 MHz.
4. Résultat : LED Rouge, OLED "Signal RF".

Wi-Fi/BLE

1. Appuie S2.
2. Résultat : OLED affiche réseaux.

OLED

1. Batterie.
2. Résultat : "HackBox 15-en-1".

Buzzer

1. Appuie S4.
2. Résultat : Bruit.

Jammer IR

1. Appuie S3.
2. Résultat : LED IR clignote.

Détecteur Magnétique

1. Approche un aimant.
2. Résultat : OLED affiche "Aimant détecté!".

Testeur Tension

1. Connecte une source (3-9V).
2. Résultat : OLED affiche tension.

Testeur Diodes

1. Connecte une diode.
2. Résultat : OLED affiche état diode.

Court-Circuit Sécurisé

1. Appuie S5.
2. Résultat : OLED affiche "Court-circuit déclenché".

Générateur Bruit Blanc

1. Appuie S6.
2. Résultat : Buzzer émet bruit blanc.

Jammer Wideband

1. Appuie S7.
2. Résultat : OLED affiche "Jammer 2.4 GHz actif".

11️⃣ Personnaliser

• Buzzer Ultrason : Piezo 25 kHz.
• Potentiomètre : 10kΩ pour LED ou bruit.
• Boîtier : 3D noir, RGB.

12️⃣ Code ESP32 Complet

Ce code gère tout : sniffer RF/Wi-Fi/BLE, OLED, LED RGB, microSD, guides, capteur magnétique, testeur tension/diodes, court-circuit sécurisé, bruit blanc, jammer 2.4 GHz. Copie dans Arduino IDE.

#include <WiFi.h>
#include <BLEDevice.h>
#include <BLEScan.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <SPI.h>
#include <SD.h>
#include <ELECHOUSE_CC1101_SRC_DRV.h>
#include <EEPROM.h>
#include <Adafruit_MCP4725.h>
#include <USB.h> // Pour HID (Backdoor USB)

// Configuration OLED
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Configuration DAC
Adafruit_MCP4725 dac;

// Pins ESP32
#define RGB_R 18
#define RGB_G 19
#define RGB_B 23
#define BUZZER_PIN 25
#define PHOTO_RESISTOR 34
#define TOUCH_SENSOR 33
#define IR_JAMMER_CTRL 32
#define BUTTON_RF 26
#define BUTTON_WIFI 27
#define BUTTON_IR 14
#define BUTTON_BUZZER 12
#define BUTTON_TEST 13
#define SD_CS 15
#define CC1101_GDO0 4
#define CC1101_CS 5
#define REED_SWITCH 13
#define VOLTAGE_SENSOR 35
#define SHORT_CIRCUIT_CTRL 27

// Sécurité
#define MAX_PIN_ATTEMPTS 3
#define EEPROM_SIZE 1
String correctPin = "1234";

// Variables globales
BLEScan* pBLEScan;
int pinAttempts = 0;
bool systemLocked = false;
unsigned long lastActivity = 0;
const unsigned long INACTIVITY_TIMEOUT = 300000;
byte currentMode = 0;
const byte TOTAL_MODES = 10;

void setup() {
  Serial.begin(115200);
  EEPROM.begin(EEPROM_SIZE);
  USB.begin();
  
  // Initialisation des broches
  pinMode(RGB_R, OUTPUT);
  pinMode(RGB_G, OUTPUT);
  pinMode(RGB_B, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(IR_JAMMER_CTRL, OUTPUT);
  pinMode(SHORT_CIRCUIT_CTRL, OUTPUT);
  pinMode(BUTTON_RF, INPUT_PULLUP);
  pinMode(BUTTON_WIFI, INPUT_PULLUP);
  pinMode(BUTTON_IR, INPUT_PULLUP);
  pinMode(BUTTON_BUZZER, INPUT_PULLUP);
  pinMode(BUTTON_TEST, INPUT_PULLUP);
  pinMode(PHOTO_RESISTOR, INPUT);
  pinMode(TOUCH_SENSOR, INPUT);
  pinMode(REED_SWITCH, INPUT_PULLUP);
  pinMode(VOLTAGE_SENSOR, INPUT);

  // Initialisation OLED
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("Échec OLED"));
    errorBlink();
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("HackBox 15-en-1");
  display.display();
  delay(2000);

  // Initialisation carte SD
  if (!SD.begin(SD_CS)) {
    displayError("Erreur SD Card");
  }

  // Initialisation CC1101
  ELECHOUSE_cc1101.Init();
  if (!ELECHOUSE_cc1101.getCC1101()) {
    displayError("CC1101 Error");
  }
  ELECHOUSE_cc1101.setMHZ(433.92);
  ELECHOUSE_cc1101.SetRx();

  // Initialisation BLE
  BLEDevice::init("HackBox Scanner");
  pBLEScan = BLEDevice::getScan();
  pBLEScan->setActiveScan(true);
  pBLEScan->setInterval(100);
  pBLEScan->setWindow(99);

  // Initialisation DAC
  dac.begin(0x60);

  // Vérification PIN
  checkSecurity();
}

void loop() {
  if (systemLocked) {
    display.clearDisplay();
    display.setCursor(0,0);
    display.println("SYSTEME BLOQUE");
    display.println("Réinitialiser");
    display.display();
    errorBlink();
    return;
  }

  // Gestion timeout inactivité
  if (millis() - lastActivity > INACTIVITY_TIMEOUT) {
    enterSleepMode();
  }

  // Navigation menu
  if (digitalRead(BUTTON_TEST) == LOW) {
    currentMode = (currentMode + 1) % TOTAL_MODES;
    lastActivity = millis();
    delay(200); // Anti-rebond
  }

  // Affichage menu
  display.clearDisplay();
  display.setCursor(0,0);
  display.println("HackBox 15-en-1");
  display.println("Mode:");
  switch(currentMode) {
    case 0: display.println("1. Sniffer RF"); break;
    case 1: display.println("2. WiFi/BLE"); break;
    case 2: display.println("3. Jammer IR"); break;
    case 3: display.println("4. Test Buzzer"); break;
    case 4: display.println("5. Test Tension"); break;
    case 5: display.println("6. Test Diode"); break;
    case 6: display.println("7. Backdoor USB"); break;
    case 7: display.println("8. Signal Carré"); break;
    case 8: display.println("9. Bruit Blanc"); break;
    case 9: display.println("10. Jammer 2.4GHz"); break;
  }
  display.println("Appuyez pour changer");
  display.display();

  // Gestion des modes
  if (digitalRead(BUTTON_RF) == LOW) {
    lastActivity = millis();
    if (currentMode == 0) rfSnifferMode();
    else if (currentMode == 6) backdoorUSB();
    else if (currentMode == 7) squareWaveGenerator();
    else if (currentMode == 9) widebandJammer();
  }
  else if (digitalRead(BUTTON_WIFI) == LOW) {
    lastActivity = millis();
    if (currentMode == 1) wifiBleScanner();
  }
  else if (digitalRead(BUTTON_IR) == LOW) {
    lastActivity = millis();
    if (currentMode == 2) irJammer();
  }
  else if (digitalRead(BUTTON_BUZZER) == LOW) {
    lastActivity = millis();
    if (currentMode == 3) buzzerTest();
    else if (currentMode == 4) voltageTest();
    else if (currentMode == 5) diodeTest();
    else if (currentMode == 8) whiteNoiseGenerator();
  }

  // Surveillance capteurs
  monitorLight();
  monitorTouch();
  monitorReedSwitch();
  monitorShortCircuit();

  // Animation RGB
  static unsigned long lastRGBChange = 0;
  if (millis() - lastRGBChange > 1000) {
    cycleRGB();
    lastRGBChange = millis();
  }

  delay(100);
}

// Fonctions principales
void rfSnifferMode() {
  display.clearDisplay();
  display.println("Sniffer RF");
  display.println("Fréq: 433.92MHz");
  display.display();

  ELECHOUSE_cc1101.SetRx();
  digitalWrite(RGB_R, HIGH);
  
  unsigned long startTime = millis();
  while (millis() - startTime < 30000) {
    if (ELECHOUSE_cc1101.CheckRxFifo(100)) {
      byte buffer[61] = {0};
      byte len = ELECHOUSE_cc1101.ReceiveData(buffer);
      
      display.clearDisplay();
      display.println("Signal RF détecté!");
      display.print("Longueur: ");
      display.println(len);
      display.display();

      // Analyse codes roulants (basique)
      String code = "";
      for (byte i = 0; i < len; i++) {
        code += String(buffer[i], HEX);
      }

      // Enregistrement
      File dataFile = SD.open("/rf_log.txt", FILE_WRITE);
      if (dataFile) {
        dataFile.print("RF Data: ");
        dataFile.println(code);
        dataFile.close();
      }
      
      beep(200, 100);
      delay(1000);
    }
    
    if (digitalRead(BUTTON_RF) == HIGH) break;
  }
  
  digitalWrite(RGB_R, LOW);
}

void wifiBleScanner() {
  display.clearDisplay();
  display.println("Scan WiFi/BLE...");
  display.display();
  
  // Scan WiFi
  int wifiNetworks = WiFi.scanNetworks();
  display.println("WiFi Networks:");
  for (int i = 0; i < wifiNetworks && i < 5; i++) {
    display.print("- ");
    display.println(WiFi.SSID(i));
  }
  display.display();

  File wifiFile = SD.open("/wifi_log.txt", FILE_WRITE);
  if (wifiFile) {
    wifiFile.println("WiFi Networks:");
    for (int i = 0; i < wifiNetworks; i++) {
      wifiFile.print(WiFi.SSID(i));
      wifiFile.print(" (");
      wifiFile.print(WiFi.RSSI(i));
      wifiFile.println("dBm)");
    }
    wifiFile.close();
  }

  delay(2000);

  // Scan BLE
  display.clearDisplay();
  display.println("Scan BLE...");
  display.display();
  
  BLEScanResults foundDevices = pBLEScan->start(5, false);
  display.clearDisplay();
  display.println("BLE Devices:");
  for (int i = 0; i < foundDevices.getCount() && i < 5; i++) {
    display.print("- ");
    display.println(foundDevices.getDevice(i).getName().c_str());
  }
  display.display();

  File bleFile = SD.open("/ble_log.txt", FILE_WRITE);
  if (bleFile) {
    bleFile.println("BLE Devices:");
    for (int i = 0; i < foundDevices.getCount(); i++) {
      bleFile.println(foundDevices.getDevice(i).getName().c_str());
    }
    bleFile.close();
  }

  pBLEScan->clearResults();
  delay(2000);
}

void irJammer() {
  display.clearDisplay();
  display.println("Jammer IR Actif");
  display.println("30 secondes...");
  display.display();
  
  digitalWrite(IR_JAMMER_CTRL, HIGH);
  digitalWrite(RGB_B, HIGH);
  
  unsigned long startTime = millis();
  while (millis() - startTime < 30000) {
    if (digitalRead(BUTTON_IR) == HIGH) break;
    delay(100);
  }
  
  digitalWrite(IR_JAMMER_CTRL, LOW);
  digitalWrite(RGB_B, LOW);

  File logFile = SD.open("/ir_log.txt", FILE_WRITE);
  if (logFile) {
    logFile.println("IR Jammer activé à ");
    logFile.println(millis());
    logFile.close();
  }
}

void buzzerTest() {
  display.clearDisplay();
  display.println("Test Buzzer");
  display.println("3 bips...");
  display.display();
  
  for (int i = 0; i < 3; i++) {
    tone(BUZZER_PIN, 1000);
    delay(200);
    noTone(BUZZER_PIN);
    delay(200);
  }

  File logFile = SD.open("/buzzer_log.txt", FILE_WRITE);
  if (logFile) {
    logFile.println("Buzzer testé à ");
    logFile.println(millis());
    logFile.close();
  }
}

void voltageTest() {
  display.clearDisplay();
  display.println("Test Tension");
  float voltage = readVoltage(VOLTAGE_SENSOR);
  display.print("Tension: ");
  display.print(voltage);
  display.println("V");
  display.display();

  File logFile = SD.open("/voltage_log.txt", FILE_WRITE);
  if (logFile) {
    logFile.print("Voltage: ");
    logFile.print(voltage);
    logFile.println("V");
    logFile.close();
  }
  delay(2000);
}

void diodeTest() {
  display.clearDisplay();
  display.println("Test Diode...");
  bool result = testDiode();
  display.println(result ? "Diode OK" : "Diode KO");
  display.display();

  File logFile = SD.open("/diode_log.txt", FILE_WRITE);
  if (logFile) {
    logFile.print("Diode Test: ");
    logFile.println(result ? "OK" : "KO");
    logFile.close();
  }
  beep(result ? 1000 : 200, 200);
  delay(2000);
}

void backdoorUSB() {
  display.clearDisplay();
  display.println("Backdoor USB");
  display.println("Envoi commande...");
  display.display();

  // Simule HID (exemple : ouvre notepad)
  USB.keyboardPress(KEY_LEFT_CTRL, KEY_T);
  USB.keyboardReleaseAll();
  delay(500);
  USB.print("notepad");
  USB.keyboardPress(KEY_RETURN);
  USB.keyboardReleaseAll();
  delay(1000);
  USB.print("HackBox Test");
  
  File logFile = SD.open("/usb_log.txt", FILE_WRITE);
  if (logFile) {
    logFile.println("USB Command sent at ");
    logFile.println(millis());
    logFile.close();
  }
  
  beep(1000, 200);
  delay(2000);
}

void squareWaveGenerator() {
  display.clearDisplay();
  display.println("Générateur Carré");
  display.println("Fréq: 1kHz");
  display.display();
  
  tone(BUZZER_PIN, 1000);
  digitalWrite(RGB_G, HIGH);
  
  unsigned long startTime = millis();
  while (millis() - startTime < 30000) {
    if (digitalRead(BUTTON_RF) == HIGH) break;
    delay(100);
  }
  
  noTone(BUZZER_PIN);
  digitalWrite(RGB_G, LOW);

  File logFile = SD.open("/square_log.txt", FILE_WRITE);
  if (logFile) {
    logFile.println("Signal carré généré à ");
    logFile.println(millis());
    logFile.close();
  }
}

void whiteNoiseGenerator() {
  display.clearDisplay();
  display.println("Bruit Blanc");
  display.println("30 secondes...");
  display.display();
  
  digitalWrite(RGB_B, HIGH);
  
  unsigned long startTime = millis();
  while (millis() - startTime < 30000) {
    // Génère bruit blanc via DAC
    uint16_t value = random(0, 4096);
    dac.setVoltage(value, false);
    delayMicroseconds(100);
    if (digitalRead(BUTTON_BUZZER) == HIGH) break;
  }
  
  dac.setVoltage(0, false);
  digitalWrite(RGB_B, LOW);

  File logFile = SD.open("/noise_log.txt", FILE_WRITE);
  if (logFile) {
    logFile.println("Bruit blanc généré à ");
    logFile.println(millis());
    logFile.close();
  }
}

void widebandJammer() {
  display.clearDisplay();
  display.println("Jammer 2.4GHz");
  display.println("30 secondes...");
  display.display();
  
  digitalWrite(IR_JAMMER_CTRL, HIGH);
  digitalWrite(RGB_R, HIGH);
  
  unsigned long startTime = millis();
  while (millis() - startTime < 30000) {
    if (digitalRead(BUTTON_RF) == HIGH) break;
    delay(100);
  }
  
  digitalWrite(IR_JAMMER_CTRL, LOW);
  digitalWrite(RGB_R, LOW);

  File logFile = SD.open("/jammer_log.txt", FILE_WRITE);
  if (logFile) {
    logFile.println("Jammer 2.4GHz activé à ");
    logFile.println(millis());
    logFile.close();
  }
}

void shortCircuitTest() {
  display.clearDisplay();
  display.println("Court-Circuit");
  display.println("Déclenché!");
  display.display();
  
  digitalWrite(SHORT_CIRCUIT_CTRL, HIGH);
  digitalWrite(RGB_R, HIGH);
  
  delay(500);
  
  digitalWrite(SHORT_CIRCUIT_CTRL, LOW);
  digitalWrite(RGB_R, LOW);

  File logFile = SD.open("/short_log.txt", FILE_WRITE);
  if (logFile) {
    logFile.println("Court-circuit déclenché à ");
    logFile.println(millis());
    logFile.close();
  }
  
  beep(500, 200);
  delay(2000);
}

// Fonctions utilitaires
void monitorLight() {
  static unsigned long lastLog = 0;
  int lightValue = analogRead(PHOTO_RESISTOR);
  
  if (millis() - lastLog > 60000) {
    File logFile = SD.open("/light_log.txt", FILE_WRITE);
    if (logFile) {
      logFile.print("Light: ");
      logFile.print(lightValue);
      logFile.println(" at ");
      logFile.println(millis());
      logFile.close();
    }
    lastLog = millis();
  }
}

void monitorTouch() {
  static unsigned long lastTouchLog = 0;
  if (digitalRead(TOUCH_SENSOR) == HIGH && millis() - lastTouchLog > 1000) {
    display.clearDisplay();
    display.println("Toucher détecté!");
    display.display();
    File logFile = SD.open("/touch_log.txt", FILE_WRITE);
    if (logFile) {
      logFile.print("Touch at ");
      logFile.println(millis());
      logFile.close();
    }
    lastTouchLog = millis();
    beep(500, 200);
    delay(1000);
  }
}

void monitorReedSwitch() {
  static unsigned long lastReedLog = 0;
  if (digitalRead(REED_SWITCH) == LOW && millis() - lastReedLog > 1000) {
    display.clearDisplay();
    display.println("Aimant détecté!");
    display.display();
    File logFile = SD.open("/reed_log.txt", FILE_WRITE);
    if (logFile) {
      logFile.print("Magnet at ");
      logFile.println(millis());
      logFile.close();
    }
    lastReedLog = millis();
    beep(1000, 200);
    delay(1000);
  }
}

void monitorShortCircuit() {
  static unsigned long lastShortLog = 0;
  if (digitalRead(BUTTON_BUZZER) == LOW && currentMode == 0 && millis() - lastShortLog > 1000) {
    shortCircuitTest();
    lastShortLog = millis();
  }
}

float readVoltage(int pin) {
  return (analogRead(pin) * 3.3 / 4095.0) * 2;
}

bool testDiode() {
  pinMode(IR_JAMMER_CTRL, OUTPUT);
  digitalWrite(IR_JAMMER_CTRL, HIGH);
  delay(100);
  float v = analogRead(PHOTO_RESISTOR) * 3.3 / 4095.0;
  digitalWrite(IR_JAMMER_CTRL, LOW);
  pinMode(IR_JAMMER_CTRL, INPUT);
  return (v > 0.7);
}

void checkSecurity() {
  byte locked = EEPROM.read(0);
  if (locked == 1) {
    systemLocked = true;
    return;
  }

  display.clearDisplay();
  display.setCursor(0,0);
  display.println("Entrez PIN (Serial)");
  display.display();

  while (pinAttempts < MAX_PIN_ATTEMPTS) {
    if (Serial.available()) {
      String input = Serial.readStringUntil('\n');
      input.trim();
      
      if (input == correctPin) {
        display.clearDisplay();
        display.println("Accès autorisé");
        display.display();
        beep(1000, 200);
        return;
      } else {
        pinAttempts++;
        display.clearDisplay();
        display.print("Essai ");
        display.print(pinAttempts);
        display.println("/3");
        display.display();
        beep(200, 500);
      }
    }
    delay(100);
  }

  EEPROM.write(0, 1);
  EEPROM.commit();
  systemLocked = true;
  display.clearDisplay();
  display.println("TROP DE TENTATIVES");
  display.println("SYSTEME BLOQUE");
  display.display();
  errorBlink();
}

void cycleRGB() {
  static byte state = 0;
  digitalWrite(RGB_R, LOW);
  digitalWrite(RGB_G, LOW);
  digitalWrite(RGB_B, LOW);
  switch(state) {
    case 0: digitalWrite(RGB_R, HIGH); break;
    case 1: digitalWrite(RGB_G, HIGH); break;
    case 2: digitalWrite(RGB_B, HIGH); break;
  }
  state = (state + 1) % 3;
}

void enterSleepMode() {
  display.clearDisplay();
  display.println("Mode veille...");
  display.println("Appuyez pour");
  display.println("réveiller");
  display.display();
  
  digitalWrite(RGB_R, LOW);
  digitalWrite(RGB_G, LOW);
  digitalWrite(RGB_B, LOW);
  
  esp_sleep_enable_ext0_wakeup(GPIO_NUM_26, LOW);
  esp_deep_sleep_start();
}

void beep(int frequency, int duration) {
  tone(BUZZER_PIN, frequency, duration);
  delay(duration);
  noTone(BUZZER_PIN);
}

void errorBlink() {
  while (1) {
    digitalWrite(RGB_R, HIGH);
    delay(200);
    digitalWrite(RGB_R, LOW);
    delay(200);
  }
}

void displayError(const char* message) {
  display.clearDisplay();
  display.setCursor(0,0);
  display.println("ERREUR:");
  display.println(message);
  display.display();
  errorBlink();
}
                

Programmer :

1. Télécharge Arduino IDE.
2. Branche ESP32 via USB-C.
3. Installe librairies : Adafruit_GFX, Adafruit_SSD1306, SPI, SD, BLE, ELECHOUSE_CC1101, Adafruit_MCP4725 (menu "Outils > Gérer les bibliothèques").
4. Copie code (à venir).
5. Sélectionne "ESP32 Dev Module", "Téléverser".
6. Moniteur série : tape "1234", Entrée.
7. Résultat : OLED affiche "HackBox".

13️⃣ Questions

Utiliser dehors ?
Non, lab only !

RF marche pas ?
Vérifie antenne PCB, fils CC1101, patte 5.

OLED noir ?
Vérifie connexions SDA/SCL (pattes 21/22), +3.3V.

Rien ne marche ?
Multimètre : 5V/3.3V OK ? Fils bien branchés ?

Reed Switch inactif ?
Vérifie patte 13, R10 (10kΩ), aimant proche.

Tension incorrecte ?
Vérifie R11/R12 (10kΩ), patte 35, source 3-9V.

Diode non détectée ?
Vérifie R13 (1kΩ), photorésistance, patte 32.

Court-circuit échoue ?
Vérifie fusible 0.5A, R14 (10Ω), S5, patte 27.

Bruit blanc silencieux ?
Vérifie MCP4725, S6, C2 (1µF), buzzer.

Jammer 2.4 GHz inactif ?
Vérifie NE555, R17 (1kΩ), antenne 2.4 GHz, S7, patte 14.

Wi-Fi/BLE ne scanne pas ?
Vérifie antenne ESP32, librairie BLE.

Backdoor USB inactif ?
Vérifie librairie USB, connexion USB-C.

Signal carré absent ?
Vérifie buzzer, patte 25, S4.

Toucher non détecté ?
Vérifie patte 33, fils de contact.

SD ne logue pas ?
Vérifie module MicroSD, patte 15, carte formatée FAT32.