Reverse-Engineering von Qualcomm Quick Charge 2.0/3.0 mit ATtiny85: Praxishandbuch

Komponenten und Zubehör

Microchip ATtiny85	×	1
SparkFun LM1117 3,3 V Spannungsregler	×	1
SparkFun USB-A-Stecker (Männlich)	×	1
Widerstand 10 kΩ	×	2
Widerstand 2,21 kΩ	×	1
Arduino Proto Shield	×	1
SparkFun Taster 12 mm	×	1
QC-Powerbank oder -Ladegerät	×	1
Steckbrücken (Generic, 2,54 mm)	×	8
Stiftleiste 36-polig, 1 Reihe, lang (2,54 mm)	×	1
Widerstand 0,05 Ω	×	10
Arduino UNO (zum Programmieren als ISP)	×	1
Steckbrücken Male/Female	×	7
LED (Standard)	×	1
Widerstand 22,1 kΩ	×	1

Benötigte Werkzeuge

• Lötkolben (Standard)

Apps und Online-Dienste

• Arduino IDE

Über dieses Projekt

Einführung

Viele USB-betriebene Geräte nutzen Qualcomm Quick Charge (QC) für schnelles Laden bei variablen Spannungen (5 V, 9 V, 12 V) statt nur 5 V. Das eröffnet die Möglichkeit, QC-kompatible Powerbanks für Projekte mit höherem Spannungs- oder Leistungsbedarf zu nutzen.

Ziel dieses Projekts ist ein Gerät, das das QC-Protokoll „knackt“ und Hobbyisten, Entwicklern und Ingenieuren ermöglicht, ihre Powerbanks für höhere Spannungen/Leistungen in ihren nächsten energiehungrigen Projekten einzusetzen.

Die Bilder zeigen 5 V, 9 V und 12 V Ausgang an einer QC-2.0-kompatiblen Powerbank, die einen 10 Ω / 5 W Lastwiderstand versorgt.

Entwicklung des Hacks – Das Gerät

Das Gerät hat zwei aktive Bauelemente: den LM1117 3,3 V-Regler und den ATtiny85-Mikrocontroller zur Steuerung. Alle anderen Teile sind Widerstände, Taster, Stecker, Jumper, Header, Klemmen, Lochrasterplatine etc.

Die Bauteile werden ordentlich platziert und verlötet. Einige 0-Ω-Brücken verbinden verschiedene Bereiche.

Jumper deaktivieren die Onboard-Schaltung zum Programmieren, da die Programmierleitungen (SPI: MOSI, MISO, SCK) im Betrieb als GPIOs dienen.

ATtiny85 per ISP programmieren

Vor dem Programmieren wird der ATtiny85 aus dem Sockel genommen und auf ein Steckbrett gesetzt. Ein Arduino UNO wird per „ArduinoISP“-Sketch (Datei → Beispiele → ArduinoISP) zum ISP-Programmer.

Schritte:

1. ATtiny-Support für Arduino IDE installieren (Dank an David A. Mellis)
2. Bootloader auf ATtiny85 brennen (Arduino UNO als ISP)
3. Code entwickeln und hochladen (Arduino UNO als ISP)

ISP = In-System-Programmer

Alternativ kann der ATtiny85 auf der Platine bleiben, wenn alle Jumper um ihn herum entfernt werden.

Gerätebetrieb

Das Gerät wird an eine QC-kompatible Powerbank (oder Ladegerät) angeschlossen. Standardmäßig liefert der USB-Ausgang 5,0 V.

Nach dem Code-Upload müssen alle Jumper gesteckt sein, damit der MCU über D+/D- mit der QC-Quelle kommunizieren kann.

Der LM1117 versorgt den ATtiny85 mit 3,3 V. Dieser führt den Code aus. Vier I/O-Pins steuern zwei Spannungsteiler (je 10 kΩ und 2,2 kΩ), um die für D+/D- nötigen Spannungspegel zu erzeugen. Ein weiterer Pin liest den Taster (Input Pullup).

Wie die Spannungsumschaltung funktioniert

Jedes USB-Kabel (A, B, C, 1.1, 2.0, 3.0+) hat mindestens vier Leitungen:

• VBUS (Vcc, standardmäßig +5 V)
• D+
• D-
• Ground

Bei normalen Ladegeräten ist VBUS fest – die Leistung wird nur über den Strom begrenzt (500 mA, 1 A, 2 A → 2,5 W, 5 W, 10 W).

QC-Quellen haben einen internen Boost-Converter, der die Spannung auf Anfrage des Powered Device (PD) erhöht. QC 2.0 (und 3.0) nutzt D+/D- zur Kommunikation: Das PD legt Spannungen auf D+/D-, das QC-Ladegerät ändert daraufhin VBUS. Laut CHY-Datenblatt gilt folgende Tabelle:

QC 2.0 wird aktiv, wenn D+ und D- die Werte der 4. Zeile mindestens 1,25 s annehmen. Fällt D+ unter 0,325 V, beendet QC den Hochspannungsmodus → 5 V. Durch Setzen der Pegel gemäß Tabelle lässt sich VBUS umschalten.

Der ATtiny85 nutzt vier Ausgänge an zwei Spannungsteilern (je 10 kΩ / 2,2 kΩ), um diese Pegel zu erzeugen.

Beispiel: Für 3,3 V an D+ werden beide zugehörigen ATtiny-Pins (PB3, PB4) auf HIGH gesetzt. Für 0,6 V an D- wird der obere Pin (PB1) HIGH, der untere (PB3) LOW geschaltet.

Der Taster ist als Input Pullup konfiguriert. Solange er nicht gedrückt ist, liest der MCU HIGH und wartet in einer while-Schleife. Beim Drücken bricht die Schleife ab, die nächste Spannungsstufe wird gesetzt, und die nächste while-Schleife wartet auf den nächsten Tastendruck.

Eine LED leuchtet schwach (5 V), mittel (9 V) und hell (12 V) als visuelle Rückmeldung.

Mögliche Anwendungen

• 12 V LED-Streifen betreiben
• RF-Sender/Empfänger für größere Reichweite versorgen
• 12 V Relais, Motoren ansteuern
• Beliebige Spannung 1,25–10 V mit LM317 oder LM2596 erzeugen
• 9 V IR-Fernbedienungen
• Roboterauto-Stromversorgung
• Laptop-Laden mit 20 V (siehe Warnung!)
• Systeme bis 18 W (WiFi, LTE, IoT-Geräte)
• Notstrom für Remote-Systeme
• LCD/LED-Monitore, Drucker, Scanner
• Leistungsschwache portable PCs

Unterstützung weiterer QC-Klassen

Da QC 2.0 Class B, QC 3.0 und QC 4.0 abwärtskompatibel zu QC 2.0 Class A sind, funktioniert das Gerät vermutlich mit allen aktuellen Ladegeräten/Powerbanks – aber nur mit 5 V, 9 V, 12 V. Für andere Spannungen CHY 100/101/103-Datenblätter lesen und Code anpassen.

⚠ WARNUNG!

• Hochwertige QC-Powerbank/Ladegerät mit Kurzschlussschutz verwenden. Externe Lasten dürfen 18 W nicht überschreiten (Leistungsschild prüfen).
• 20 V Ausgabe vermeiden! Der LM1117 verträgt max. 15 V am Eingang. Im MCU-Code niemals D+ und D- gleichzeitig auf 3,3 V setzen.
• Falls 20 V nötig (QC 2.0 Class B, QC 3.0, 4.0): Regler (z. B. LM317 auf 3,3 V) verwenden, der >20 V verträgt. Sonst Regler und MCU werden zerstört!
• Auf Ausgangspolarität achten (Rot = +, Blau = - an der Ausganklemme).
• Lose USB-Kontakte vermeiden – Kontaktwiderstand erzeugt Hitze und verringert Wirkungsgrad.
• Während ISP-Programmierung alle Jumper entfernen, um MOSI, MISO, SCK, VCC, GND, RESET vom Rest der Schaltung zu isolieren.
• Code nicht ändern ohne QC-Protokoll-Verständnis. Design primär für QC 2.0 Class A, teilweise nutzbar für höhere Standards.
• Hack funktioniert nicht mit allen QC-Ladegeräten/Powerbanks.
• GPIO-Umschaltung muss in korrekter Reihenfolge erfolgen, um Abbruch des Hochspannungsmodus zu vermeiden.

Hinweis: Nachbau nur bei Verständnis aller obigen Punkte – sonst Brandgefahr oder Geräteschaden!

Spannungen lassen sich auch manuell ohne Mikrocontroller umschalten: Nur 4 Jumper-Drähte nötig, um die D+/D--Bedingungen der Tabelle durch Verbinden mit Vcc (3,3 V) und GND (0 V) an den Widerständen nachzubilden. Ein MCU ist für so simple Übergänge oft Overkill.

Referenzen

• CHY Family Datasheet (Mouser)
• Wikipedia: Quick Charge
• TI Application Note

Code

ATtiny85 Code (C/C++)

QC Controller

///========================= Algorithmus ========================///
/* 1. D+ auf 0,325–2 V ziehen, D- offen lassen, ≥2 s warten.
   Dabei passiert: D+/D- sind intern im CHY100 kurzgeschlossen → beide 0,325–2 V für 1,25 s.
   Dann trennen sie sich, interner Widerstand zieht D- auf 0 V.
   CHY100 = QC-2.0-Protokollchip in Powerbank/Ladegerät (andere ähnlich).

2. D+ auf >3,0 V, dann D- auf 0,325–2 V → VBUS springt auf 9 V.
3. D- auf 0,325–2 V halten, D+ auf 0,325–2 V → VBUS springt auf 12 V.
4. D+ von 0,325–2 V trennen → VBUS fällt auf 5 V (QC-Modus Ende).
   Von vorne beginnen, um QC wieder zu aktivieren.
*/
// ============ WICHTIGER HINWEIS ================
// *** Reihenfolge von HIGH/LOW an den Pins ist kritisch!
// *** Fällt D+ durch falsche GPIO-Sequenz unter 0,325 V,
// *** verlässt QC 2.0 den Hochspannungsmodus → 5 V.
// ===============================================
#define PUSH_SWITCH 0
#define Dp_2k2 4
#define Dp_10k 3
#define Dn_2k2 2
#define Dn_10k 1

int Press_Detect = 0;

void setup() {
  pinMode(PUSH_SWITCH, INPUT_PULLUP);
  // QC-Handshake initiieren: D+ = 0,6 V, D- = GND
  Init_QC();
}

void loop() {
  //// 5 V ////
  while (digitalRead(PUSH_SWITCH) == 1) { }
  delay(250);

  //// 9 V ////
  Set_9V();
  while (digitalRead(PUSH_SWITCH) == 1) { }
  delay(250);

  //// 12 V ////
  Set_12V();
  while (digitalRead(PUSH_SWITCH) == 1) { }
  delay(250);

  // Set_5V(); // optional zurück zu 5 V
}

///********************** Funktionen **********************///
void Init_QC() {
  pinMode(Dp_2k2, OUTPUT);
  pinMode(Dp_10k, OUTPUT);
  digitalWrite(Dp_2k2, LOW);
  digitalWrite(Dp_10k, HIGH);
  delay(3000); // QC-Protokoll aktiv
}

void Set_9V() {
  pinMode(Dp_2k2, OUTPUT); pinMode(Dp_10k, OUTPUT);
  digitalWrite(Dp_10k, HIGH); digitalWrite(Dp_2k2, HIGH);
  pinMode(Dn_2k2, OUTPUT); pinMode(Dn_10k, OUTPUT);
  digitalWrite(Dn_2k2, LOW); digitalWrite(Dn_10k, HIGH);
}

void Set_12V() {
  pinMode(Dp_2k2, OUTPUT); pinMode(Dp_10k, OUTPUT);
  pinMode(Dn_2k2, OUTPUT); pinMode(Dn_10k, OUTPUT);
  digitalWrite(Dn_2k2, LOW); digitalWrite(Dn_10k, HIGH);
  digitalWrite(Dp_10k, HIGH); digitalWrite(Dp_2k2, LOW);
}

void Set_5V() {
  pinMode(Dp_2k2, OUTPUT); pinMode(Dp_10k, OUTPUT);
  digitalWrite(Dp_10k, HIGH); digitalWrite(Dp_2k2, LOW);
  pinMode(Dn_2k2, OUTPUT); pinMode(Dn_10k, OUTPUT);
  digitalWrite(Dn_2k2, LOW); digitalWrite(Dn_10k, LOW);
}

void Set_20V() {
  // Spannungsregler ändern !!! – auf eigenes Risiko
}

Schaltplan

https://circuits.io/circuits/5830928-qc-chargeing-hack