Ingeniería Inversa de Qualcomm Quick Charge 2.0/3.0 con ATtiny85: Guía Práctica

Componentes y suministros

Microchip ATtiny85	×	1
Regulador LM1117 3.3V SparkFun	×	1
Conector USB Macho A SparkFun	×	1
Resistencia 10k ohm	×	2
Resistencia 2.21k ohm	×	1
Shield Proto Arduino	×	1
Pulsador 12mm SparkFun	×	1
Power Bank o Cargador QC	×	1
Jumper genérico (0.1")	×	8
Header macho 36 posiciones 1 fila	×	1
Resistencia 0.05 ohm	×	10
Arduino UNO (para programación)	×	1
Cables jumper Macho/Hembra	×	7
LED (genérico)	×	1
Resistencia 22.1k ohm	×	1

Herramientas necesarias

• Soldador

Aplicaciones y servicios online

• Arduino IDE

Sobre el proyecto

Introducción

Muchos dispositivos electrónicos de consumo alimentados por USB incorporan la solución Qualcomm Quick Charge (QC) para carga rápida a distintos voltajes, no solo los 5,0V habituales. Esto permite usar Power Banks compatibles con QC para proyectos que requieren más potencia o voltajes mayores como 9/12V.

El objetivo de este proyecto es desarrollar un dispositivo que «hackee» el protocolo QC y permita a aficionados, desarrolladores e ingenieros usar sus power banks para obtener más voltaje/potencia en sus próximos proyectos hambrientos de energía.

Las imágenes muestran salidas de 5, 9 y 12 Voltios desde un power bank compatible QC 2.0 alimentando una resistencia de 10 Ohmios 5 Watt.

Desarrollo del Hack / Dispositivo

El dispositivo tiene dos componentes activos: el regulador LM1117 3.3V y el MCU ATtiny85 para control. El resto son resistencias, pulsador, conectores, jumpers, headers, terminal, protoboard, etc.

Para construirlo, primero se colocan los componentes en una disposición ordenada y luego se sueldan. Se usan enlaces cortos de 0 ohmios para interconectar partes.

Hay jumpers para deshabilitar el circuito a bordo y permitir la programación. Como las líneas de programación (SPI - MOSI, MISO, SCK) también actúan como GPIO durante el funcionamiento del dispositivo.

Programar ATtiny85 con ISP

Antes de programar el ATtiny85, se extrae de su zócalo y se coloca en una protoboard. Para programarlo, se convierte un Arduino UNO en programador ISP subiendo el sketch ArduinoISP desde Archivo > Ejemplos > ArduinoISP.

Pasos para programar ATtiny85:

• Instalar soporte ATtiny para Arduino IDE (gracias a David A. Mellis)
• Grabar Bootloader en ATtiny85 usando Arduino UNO como ISP
• Desarrollar y subir código usando Arduino UNO como ISP

Circuito para programar el ATtiny85:

ISP = programador en sistema

Alternativamente, el ATtiny85 puede programarse manteniéndolo en el dispositivo quitando todos los jumpers alrededor.

Funcionamiento del Dispositivo

Para usar el dispositivo, conéctalo a un Power Bank (o cargador) compatible QC. Por defecto, el voltaje del USB del Power Bank QC será 5,0 voltios.

Todos los jumpers deben estar conectados tras subir el código, para que el MCU pueda comunicarse por D+/D- con la fuente QC.

El regulador LM1117 3.3V se enciende y alimenta al ATtiny85. Este MCU empieza a ejecutar el código. 4 pines I/O del ATtiny85 están conectados a redes divisoras de tensión que se usan como Salida Alta y Baja. Otro pin I/O va a un pulsador que se inicializa como entrada Pull-Up. Este pulsador toma la entrada del usuario para cambiar el voltaje de la fuente QC.

Antes de entrar en detalles, es importante saber cómo cambiará la salida. Hay al menos 4 líneas comunes a todo tipo de USB (USB A, B, C, 1.1, 2.0, 3.0+):

• VBUS (Vcc +5V por defecto)
• D+
• D-
• Tierra

En un cargador/Power Bank normal, VBUS es fijo, limitando la entrega de potencia por corriente (500mA, 1A, 2A = 2,5W, 5W, 10W).

Pero en fuentes QC, hay un convertidor boost interno que puede subir el voltaje según la petición del dispositivo receptor (PD)!!!

QC 2.0 (y 3.0) usa D+ y D- del USB para comunicarse con el PD. El PD envía señales de voltaje en D+/D- y el cargador QC entrega potencia cambiando el voltaje de VBUS. Según la hoja de datos CHY, esta tabla explica qué par de señales en D+/D- hará que el QC entregue qué voltaje:

El soporte QC 2.0 se inicia cuando el voltaje en D+ y D- coincide con la 4ª fila de la tabla y se mantiene al menos 1,25 segundos. Si D+ cae a 0,0V (en realidad por debajo de 0,325V), el soporte QC se detiene y la salida vuelve a 5,0V. Estableciendo voltajes según esta tabla, se puede cambiar la salida en VBUS.

Aquí, las 4 salidas del ATtiny85 están conectadas a 2 redes divisoras de tensión con dos resistencias de 10k y dos de 2,2k para generar estas señales de voltaje para las líneas D+/D-.

Por ejemplo, para generar 3,3V en D+, ambas resistencias superior e inferior conectadas a dos pines de salida del ATtiny85 (PB3 y PB4) se ponen en Alto desde el código.

Para generar 0,6V en D-, las resistencias conectadas a los otros dos pines (PB1 y PB3) se ponen en Alto y Bajo respectivamente.

Así el cargador QC 2.0 recibe la petición de cambio de voltaje y cambia accordingly. El pulsador está configurado como Entrada PULLUP; sin pulsar, lo lee ALTO y el código se queda en bucle while manteniendo el voltaje actual. Al pulsar, se rompe el bucle y se establece el siguiente voltaje. Luego vuelve a entrar en el siguiente bucle while para mantener el nuevo voltaje VBUS.

Hay un LED que brilla tenue (5V), medio (9V) y fuerte (12V) para dar indicación visual del voltaje de salida.

Aplicaciones Posibles

• Alimentar tiras LED 12V
• Alimentar transmisores/receptores RF para mayor alcance
• Accionar relés, motores 12V, etc.
• Obtener cualquier voltaje entre 1,25 y 10V usando LM317 o LM2596
• Mando IR 9V
• Alimentación para coche robótico
• Carga de portátil con 20V
• Cualquier sistema hasta 18W: WiFi, LTE, dispositivos S2E para IoT
• Energía de respaldo para sistemas remotos
• La mayoría de monitores LCD/LED, impresoras, escáneres
• PC portátil de bajo consumo

Soporte para otras clases QC

Como QC 2.0 Clase B, QC 3.0 y QC 4.0 son retrocompatibles con QC 2.0 Clase A, este dispositivo podría funcionar con todos los cargadores y power banks recientes. Pero las opciones de voltaje serán 5,0, 9,0 y 12,0 voltios. Si se necesitan otros voltajes, lee las hojas de datos CHY 100, 101, 103 y modifica el código.

¡Advertencia!

• Se debe usar Power Bank o Cargador QC de Alta Calidad con Protección contra Cortocircuito. Las Cargas Externas No Deben Exceder 18 Vatios. Verifícalo en la Etiqueta de Potencia de los dispositivos.
• Evita Salida de 20 Voltios ya que el regulador 1117 3v3 solo Soporta Máximo 15 Voltios. Evítalo desde el Código del MCU Nunca permitiendo que D+ y D- tengan 3,3 Voltios al mismo tiempo.
• En caso de requerir salida de 20V (soportado por QC 2.0 Clase B y QC 3.0, QC 4.0), se debe usar un regulador (LM317 configurado para 3,3V) que soporte más de 20V. ¡De lo contrario ¡Tanto el Regulador como el MCU Serán Destruidos!
• Atención a la Polaridad del Voltaje de Salida, +ve indicado por hilo rojo y -ve por hilo azul junto al terminal de salida.
• Evita conexiones flojas en el acoplamiento USB Macho-Hembra o se generará calor por resistencia de contacto y la eficiencia energética caerá.
• Durante la Programación ISP Todos los Jumpers Deben Quitarse para aislar pines MOSI, MISO, SCK, VCC, GND, RESET del resto del circuito y Evitar Interferencias en la Programación.
• Modificación del código No Debe Hacerse sin Entender Claramente el Protocolo de Carga QC. Este diseño está Pensado Principalmente para Fuentes QC 2.0 (Clase A) pero puede usarse parcialmente para estándares QC superiores.
• El Hack Puede No Funcionar con algunos cargadores/Power Banks QC.
• El Conmutado de GPIO Debe hacerse en Secuencia Propia para Evitar Terminación del Modo Alto Voltaje.

Nota: Se Aconseja No Replicar este Proyecto si los Puntos Anteriores no son Entendidos por alguien, de lo contrario ¡Riesgo de Peligro de Incendio o Pérdida de Equipo!

Es posible cambiar los voltajes manualmente sin microcontrolador. Solo se necesitan 4 cables jumper para imitar las condiciones de la tabla D+/D- conectando a Vcc (3,3V) y Gnd (0V) las resistencias en secuencia adecuada. Porque usar MCU puede ser excesivo para transiciones tan simples.

Referencias

• Datasheet familia Chiphy
• Quick Charge en Wikipedia
• Guía TI

Código

Código ATtiny85 C/C++

Controlador QC

///========================= Algoritmo ========================/// 
/* Primero, conecta pin D+ a voltaje 0.325-2V y deja D- flotando, espera al menos 2s. 
Dos acciones en estos 2s: D+ y D- igualan voltaje 0.325-2V por 1.25s 
(porque D+ y D- se conectan dentro del CHY100 al principio). 
Luego D+ mantiene 0.325-2V y D- cae a cero 
(porque D+ y D- se desconectan y una resistencia interna del CHY100 descarga D-).
*** CHY100 es chip interfaz protocolo QC 2.0 dentro del Power bank/cargador... 
otros chips QC 2.0 probablemente similares.
Pon D+ above 3.0V primero y luego conecta D- a voltaje 0.325-2V. VBUS salta a 9V.
Manteniendo D- en 0.325-2V, pon D+ en 0.325-2V. VBUS salta a 12V.
(porque D+ y D- están entre 2V y 0.325V).
Desconecta D+ de 0.325-2V. VBUS vuelve a 5V, porque QC2.0 sale del modo cambio voltaje.
Empieza desde el principio para entrar en QC2.0 de nuevo).
*/
// ============ NOTA IMPORTANTE ================
// *** Secuencia de poner pines HIGH y LOW es importante
// *** Si D+ cae bajo 0.325V durante transición por secuencia GPIO incorrecta
// *** QC 2.0 saldrá del Modo Alto Voltaje y VBUS volverá a 5 Voltios
// ==============================================
#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);
  // Iniciando handshake QC poniendo D+ 0.6v manteniendo D- en 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();
}

///********************** Funciones **********************///
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);
  // ahora protocolo QC activo
}

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() {
  // ¡Cambia Regulador de Voltaje! ¡Bajo tu propio riesgo!
}

Esquemáticos

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