Rétro-ingénierie du Qualcomm Quick Charge 2.0/3.0 avec ATtiny85 : Guide pratique

Composants et fournitures

	Microchip Technology ATtiny85	×	1
	Régulateur SparkFun LM1117 3,3V	×	1
	Connecteur USB mâle Type A SparkFun	×	1
	Résistance 10 kΩ	×	2
	Résistance 2,21 kΩ	×	1
	Shield proto Arduino	×	1
	Bouton poussoir SparkFun 12mm	×	1
	Power Bank ou chargeur QC	×	1
	Cavalier générique (0,1")	×	8
	Connecteur mâle 36 positions 1 rangée - Long (0,1")	×	1
	Résistance 0,05 Ω	×	10
	Arduino UNO	×	1
	Fils de connexion Mâle/Femelle	×	7
	LED (générique)	×	1
	Résistance 22,1 kΩ	×	1

Outils et machines nécessaires

Fer à souder (générique)

Applications et services en ligne

Arduino IDE

À propos du projet

Introduction

De nombreux appareils électroniques grand public alimentés par USB intègrent la solution Qualcomm Quick Charge (QC) pour une charge rapide à différentes tensions, au lieu des 5,0 volts habituels. Cela permet d'utiliser des Power Banks compatibles QC pour des projets nécessitant plus de puissance ou des tensions plus élevées comme 9/12 volts.

Le but de ce projet est de développer un dispositif capable de pirater le protocole QC et de permettre aux amateurs, développeurs et ingénieurs d'utiliser leurs power banks pour obtenir plus de tension/puissance pour leurs prochains projets gourmands en énergie.

Les images ci-dessus montrent des sorties 5, 9 et 12 volts provenant d'une power bank compatible QC 2.0 alimentant une résistance de 10 Ω 5 Watts.

Développement du piratage - Dispositif

L'ensemble du dispositif comporte deux composants actifs : le régulateur de tension LM1117 3,3V et le microcontrôleur ATtiny85 pour le contrôle. Tous les autres composants sont des résistances, un bouton poussoir, connecteurs, cavaliers, headers, bornier, plaque de prototypage, etc.

Pour construire le dispositif, on place d'abord les composants dans un agencement soigné, puis on soude. Des liaisons 0 ohm sont utilisées pour interconnecter différentes parties.

Des cavaliers permettent de désactiver le circuit embarqué et d'activer la programmation. En effet, les lignes de programmation (SPI - MOSI, MISO, SCK) servent aussi de GPIO pendant le fonctionnement du dispositif.

Programmation de l'ATtiny85 avec ISP

Avant de programmer l'ATtiny85, il faut le retirer de son support et le placer sur une plaque d'essai. Pour programmer l'ATtiny85, une carte Arduino UNO est convertie en programmeur ISP en téléversant le sketch ArduinoISP depuis Fichier > Exemples > ArduinoISP. Ce sketch est disponible dans l'IDE Arduino.

La programmation de l'ATtiny85 nécessite les étapes suivantes :

• Installation du support ATtiny pour l'IDE Arduino (merci à David A. Mellis)
• Gravure du bootloader pour ATtiny85 en utilisant l'Arduino UNO comme ISP
• Développement et téléversement du code en utilisant l'Arduino UNO comme ISP

Le circuit suivant est préparé pour programmer l'ATtiny85 :

ISP = programmeur en système

Alternativement, l'ATtiny85 peut être programmé en le laissant sur le dispositif en retirant tous les cavaliers autour.

Fonctionnement du dispositif

Pour utiliser le dispositif, il faut d'abord le connecter à une Power Bank (ou chargeur) compatible QC. Par défaut, la tension de l'USB de la Power Bank QC sera de 5,0 volts.

Tous les cavaliers doivent être connectés après le téléversement du code, afin que le MCU puisse communiquer sur D+/D- avec la source QC.

Le régulateur LM1117 3,3V s'alimente et alimente l'ATtiny85. Ce MCU commence à exécuter le code. 4 broches I/O de l'ATtiny85 sont connectées aux résistances du diviseur de tension qui serviront de sorties High et Low. Une autre broche I/O est connectée à un interrupteur qui s'initialise en entrée Pull-Up. Cet interrupteur prend l'entrée utilisateur pour changer la tension de la source QC.

Avant d'entrer dans les détails, il est important de comprendre comment la sortie va changer. Il y a au moins 4 fils/lignes communs à tous les types d'USB (USB A, B, C, 1.1, 2.0, 3.0+) :

• VBUS (Vcc +5V par défaut)
• D+
• D-
• Masse

Dans un chargeur/Power Bank ordinaire, VBUS est fixe, ce qui limite la délivrance de puissance par le courant (500 mA, 1 A, 2 A donnant 2,5 W, 5 W et 10 W respectivement).

Mais dans les sources d'alimentation QC, il y a un convertisseur boost interne qui peut augmenter la tension selon la demande de l'appareil receveur (PD) !!!

QC 2.0 (aussi 3.0) utilise D+ et D- de l'USB pour communiquer avec le PD. Le PD envoie des signaux de tension sur D+ et D- et le chargeur QC délivre la puissance en changeant la tension VBUS. Selon la datasheet CHY, voici un tableau expliquant quel couple de signaux sur D+/D- du PD fera délivrer quelle tension de sortie par le QC :

Le support QC 2.0 s'initie lorsque la tension sur D+ et D- sont les mêmes que les valeurs de la 4ème ligne de ce tableau et restent ainsi pendant au moins 1,25 secondes. Si D+ devient 0,0 volt (en dessous de 0,325 volts en réalité), le support QC s'arrête et la sortie revient à 5,0 volts. En réglant les tensions selon ce tableau, la sortie sur VBUS peut être modifiée.

Ici, les 4 sorties de l'ATtiny85 sont connectées à 2 réseaux diviseurs de tension composés de deux résistances 10k et deux 2,2k pour générer ces signaux de tension pour les lignes D+/D-.

Par exemple, pour générer 3,3 V sur D+, les deux résistances haute et basse connectées à deux broches de sortie de l'ATtiny85 (PB3 et PB4) seront toutes deux mises à l'état High par le code.

De même, pour générer 0,6 V sur D-, les deux résistances haute et basse connectées aux deux autres broches de sortie de l'ATtiny85 (PB1 et PB3) seront mises respectivement High et Low.

Ainsi, le chargeur/power bank QC 2.0 reçoit la demande de changement de tension et s'adapte en conséquence. Le bouton poussoir est configuré en entrée PULLUP ; tant qu'il n'est pas pressé, il est lu HIGH par le MCU et l'exécution du code reste bloquée dans une boucle while empêchant tout changement de tension réglée. Quand l'utilisateur appuie sur le bouton, la boucle while se brise et la tension suivante est réglée. Ensuite, l'exécution du code entre dans la prochaine boucle while pour maintenir la tension VBUS actuelle.

Une LED brille faiblement (5V), modérément (9V) et fort (12V) pour donner une représentation visuelle de la tension de sortie à l'utilisateur.

Applications possibles

• Alimentation de bandes LED 12V
• Alimentation d'émetteurs/récepteurs RF pour une plus grande portée
• Commande de relais 12V, moteurs, etc.
• Obtenir n'importe quelle tension entre 1,25 et 10 volts en utilisant un LM317 ou LM2596
• Commande de télécommande IR 9V
• Alimentation de voiture robotique
• Charge d'ordinateur portable avec 20V
• Tout système jusqu'à 18 Watts comme WiFi, LTE, dispositifs S2E pour applications IoT
• Alimentation de secours pour systèmes distants
• La plupart des moniteurs LCD, LED, imprimantes, scanners
• PC portable à faible consommation

Support pour d'autres classes QC

Puisque QC 2.0 Classe B, QC 3.0 et QC 4.0 sont rétrocompatibles avec QC 2.0 Classe A, ce dispositif pourrait fonctionner avec tous les derniers chargeurs et power banks. Mais les options de tension seront 5,0, 9,0 et 12,0 volts. Si d'autres tensions de sortie sont nécessaires, veuillez lire les datasheets CHY 100, 101, 103 et modifier le code en conséquence.

Avertissement !

• Une Power Bank ou un chargeur QC de haute qualité avec protection contre les courts-circuits doit être utilisé, les charges externes ne doivent pas dépasser 18 Watts. Cela peut être assuré en vérifiant l'étiquette de puissance nominale sur les appareils de charge.
• La sortie 20 volts doit être évitée car le régulateur 1117 3v3 ne peut supporter au maximum 15 volts, cela doit être évité dans le code du MCU en n'autorisant jamais les lignes D+ et D- à avoir 3,3 volts simultanément.
• Si une sortie 20 volts est requise (supportée par QC 2.0 Classe B et QC 3.0, QC 4.0), un régulateur de tension (LM317 configuré pour 3,3V) capable de supporter plus de 20 volts doit être utilisé. Sinon, le régulateur et le MCU seront détruits !!!!
• Une attention particulière doit être portée à la polarité de la tension de sortie, + indiqué par un fil rouge minuscule et - par un fil bleu minuscule à côté du bornier de sortie.
• Les connexions lâches au niveau du couplage USB mâle-femelle doivent être évitées sinon de la chaleur sera générée par la résistance de contact et l'efficacité énergétique chutera.
• Pendant la programmation ISP, tous les cavaliers doivent être retirés pour isoler les broches MOSI, MISO, SCK, VCC, GND, RESET du reste des circuits sur la carte afin d'éviter les interférences avec la programmation.
• La modification du code ne doit pas être faite sans bien comprendre le protocole de charge QC. Ce design est principalement destiné aux sources d'alimentation QC 2.0 (Classe A) mais peut être partiellement utilisé pour des standards QC supérieurs.
• Le piratage pourrait ne pas fonctionner avec certains chargeurs/power banks QC.
• La commutation des GPIO doit être faite dans la bonne séquence pour éviter la terminaison du mode haute tension.

Note : Il est déconseillé de reproduire ce projet si les points ci-dessus ne sont pas compris par quelqu'un, sinon un risque d'incendie ou de perte de matériel peut survenir !

Il est possible de changer les tensions manuellement sans utiliser de microcontrôleur. Seulement 4 fils cavaliers sont nécessaires pour imiter les conditions du tableau D+/D- en les connectant à Vcc (3,3V) et Gnd (0V) aux résistances dans la bonne séquence. Car utiliser un MCU peut être excessif pour de telles transitions simples après tout.

Références

• https://www.mouser.com/ds/2/328/chiphy_family_datasheet-269468.pdf
• https://en.wikipedia.org/wiki/Quick_Charge
• https://www.ti.com/lit/ug/tidu917/tidu917.pdf

Code

• Code ATtiny85

Code ATtiny85 C/C++

Contrôleur QC

///========================= Algorithme ========================/// 
/* D'abord, connecter la broche D+ à une tension de 0,325 à 2 volts et laisser D- flottant, puis attendre au moins 2 secondes. Deux actions se produisent pendant ces 2 secondes : La tension D+ et D- égalent une tension entre 0,325 et 2 volts pendant 1,25 secondes. (car les broches D+ et D- se connectent ensemble à l'intérieur du CHY100 au début) Ensuite, D+ reste à une tension entre 0,325 et 2 volts et la tension D- diminue jusqu'à zéro. (car les broches D+ et D- se déconnectent et une résistance à l'intérieur du CHY100 décharge D-)*** CHY100 est une puce d'interface protocole QC 2.0 à l'intérieur de la power bank/chargeur ........ les autres puces QC 2.0 sont probablement similaires. Mettre D+ au-dessus de 3,0 V d'abord, puis connecter D- à une tension entre 0,325 et 2 volts. VBUS passe à 9V. Tout en maintenant la connexion D- avec une tension entre 0,325 et 2 volts, mettre D+ à une tension entre 0,325 et 2 volts. VBUS passe à 12V. (car les tensions D+ et D- sont entre 2V et 0,325V) Déconnecter D+ d'une tension entre 0,325 et 2 volts. VBUS revient à 5V, car le QC2.0 sort du mode changement de tension et VBUS revient à la valeur par défaut 5V. (recommencer depuis le début quand on a besoin de rentrer à nouveau en QC2.0) */ 
// ============ NOTE IMPORTANTE ================ 
// 
// *** La séquence de mise à HIGH et LOW des broches est importante 
// *** Si D+ tombe en dessous de 0,325V pendant la transition à cause d'une mauvaise séquence de commutation GPIO 
// *** Le QC 2.0 sortira du mode haute tension et VBUS reviendra à 5 Volts 
// ============================================== 
// 
#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); 
  // Initialisation de la poignée de main QC en mettant D+ à 0,6v en gardant D- à Gnd 
  Init_QC(); 
} 
void loop() { 
  //// 5V //// 
  while (digitalRead(PUSH_SWITCH) == 1) { 
  } 
  delay(250); 
  //// 9v //// 
  Set_9V(); 
  while (digitalRead(PUSH_SWITCH) == 1) { 
  } 
  delay(250); 
  //// 12v //// 
  Set_12V(); 
  while (digitalRead(PUSH_SWITCH) == 1) { 
  } 
  delay(250); 
  // Set_5V(); 
} 
///********************** Fonctions **********************/// 
void Init_QC() { 
  //pinMode(Dn_2k2, INPUT); 
  //pinMode(Dn_10k, INPUT); 
  pinMode(Dp_2k2, OUTPUT); 
  pinMode(Dp_10k, OUTPUT); 
  digitalWrite(Dp_2k2, LOW); 
  digitalWrite(Dp_10k, HIGH); 
  delay(3000); 
  // maintenant le protocole QC est actif 
} 
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() { 
  // changer le régulateur de tension !!! 
  // à vos risques et périls 
} 

Schémas

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