Engenharia Reversa do Qualcomm Quick Charge 2.0/3.0 com ATtiny85: Guia Prático

Componentes e Materiais

Componente	Quantidade
Microchip ATtiny85	1
Regulador de Tensão LM1117 3.3V (SparkFun)	1
Conector USB Macho Tipo A (SparkFun)	1
Resistor 10k Ω	2
Resistor 2.21k Ω	1
Arduino Proto Shield	1
Chave Tactil 12mm (SparkFun)	1
Power Bank ou Carregador com QC	1
Jumpers Genéricos (0.1")	8
Header Macho 36 Pinos 1 Fileira	1
Resistor 0.05 Ω	10
Arduino UNO	1 (para programação ISP)
Jumpers Macho/Fêmea	7
LED (genérico)	1
Resistor 22.1k Ω	1

Ferramentas Necessárias

• Ferro de Solda

Aplicativos e Serviços Online

• Arduino IDE

Sobre o Projeto

Introdução

Muitos dispositivos eletrônicos alimentados por USB possuem solução Qualcomm Quick Charge (QC) para carregamento rápido em diferentes tensões, além dos habituais 5V. Isso permite usar Power Banks compatíveis com QC para projetos que exigem mais potência ou tensões maiores, como 9V ou 12V.

O objetivo deste projeto é desenvolver um dispositivo que "hackeie" o protocolo QC, permitindo que hobbyistas, desenvolvedores e engenheiros usem seus power banks para obter mais tensão/potência em projetos exigentes.

As imagens acima mostram saídas de 5V, 9V e 12V de um power bank compatível QC 2.0 alimentando um resistor de 10Ω 5W.

Desenvolvimento do Hack – Dispositivo

O dispositivo possui dois componentes ativos: o regulador LM1117 3.3V e o MCU ATtiny85. Todos os demais são resistores, chave, conectores, jumpers, headers, terminal, protoboard, etc.

Para construir, primeiro organize os componentes de forma limpa e depois solde. Alguns jumpers de 0Ω são usados para interconexões.

Existem jumpers para desabilitar o circuito embarcado e habilitar a programação, pois as linhas de programação (SPI – MOSI, MISO, SCK) também atuam como GPIO durante a operação.

Programando ATtiny85 com ISP

Antes de programar, o ATtiny85 é removido da base e colocado em uma protoboard. Para programar, um Arduino UNO é convertido em programador ISP carregando o sketch ArduinoISP (em Arquivo > Exemplos > ArduinoISP).

Passos para programar o ATtiny85:

1. Instalar suporte ATtiny para Arduino IDE (graças a David A. Mellis).
2. Gravar Bootloader no ATtiny85 usando Arduino UNO como ISP.
3. Desenvolver e carregar o código usando Arduino UNO como ISP.

Circuito para programação:

ISP = Programador em Sistema

Alternativamente, o ATtiny85 pode ser programado mantido no dispositivo, removendo todos os jumpers ao redor dele.

Operação do Dispositivo

Para usar, conecte o dispositivo a um Power Bank (ou carregador) compatível QC. Por padrão, a saída USB QC será 5V.

Todos os jumpers devem estar conectados após o upload do código, para que o MCU comunique via D+/D- com a fonte QC.

O regulador LM1117 3.3V alimenta o ATtiny85, que inicia a execução. 4 pinos I/O do ATtiny85 conectam-se a redes divisoras de tensão (dois resistores 10k e dois 2.2k) para gerar sinais de nível Alto/Baixo nas linhas D+/D-. Outro pino I/O conecta-se a uma chave configurada como entrada Pull-Up. Esta chave recebe a entrada do usuário para alterar a tensão da fonte QC.

Antes de detalhar, é importante saber como a saída muda. Todo USB possui pelo menos 4 linhas: VBUS (Vcc +5V padrão), D+, D-, Terra.

Em carregadores comuns, VBUS é fixo, limitando a potência pela corrente (ex: 500mA, 1A, 2A → 2.5W, 5W, 10W). Em fontes QC, há um conversor boost interno que eleva a tensão conforme a solicitação do dispositivo receptor (PD).

QC 2.0 (e 3.0) usa D+ e D- para comunicar com o PD. O PD envia sinais de tensão em D+/D- e o carregador QC altera a tensão VBUS. Segundo o datasheet CHY, a tabela abaixo mostra quais pares de tensão em D+/D- solicitam qual tensão de saída:

O suporte QC 2.0 inicia quando as tensões em D+ e D- correspondem aos valores da 4ª linha da tabela e permanecem por pelo menos 1.25s. Se D+ cair para 0V (abaixo de 0.325V), o suporte QC para e a saída retorna a 5V. Definindo tensões conforme a tabela, a saída VBUS pode ser alterada.

Os 4 pinos de saída do ATtiny85 conectam-se a duas redes divisoras (dois 10k e dois 2.2k) para gerar esses sinais de tensão para D+/D-.

Exemplo: para gerar 3.3V em D+, ambos os resistores superior e inferior (conectados aos pinos PB3 e PB4 do ATtiny85) são colocados em High. Para gerar 0.6V em D-, o resistor superior (PB1) em High e o inferior (PB3) em Low.

Assim, o carregador QC recebe a solicitação de mudança de tensão e ajusta. A chave é configurada como Input Pull-Up; enquanto não pressionada, lê High e o código permanece em loop while mantendo a tensão atual. Ao pressionar, o loop é quebrado e a próxima tensão é definida. Em seguida, entra no próximo loop while para manter a nova tensão.

Um LED indica visualmente a tensão: brilho fraco (5V), médio (9V), forte (12V).

Aplicações Possíveis

• Acionamento de fitas LED 12V
• Alimentação de transmissores/receptores RF para maior alcance
• Acionamento de relés 12V, motores, etc.
• Obtenção de qualquer tensão entre 1.25V a 10V usando LM317 ou LM2596
• Controle remoto IR 9V
• Alimentação de carro robótico
• Carregamento de laptop com 20V
• Qualquer sistema até 18W como WiFi, LTE, dispositivos S2E para IoT
• Backup de energia para sistemas remotos
• Monitores LCD/LED, impressoras, scanners
• PC portátil de baixa potência

Suporte para Outras Classes QC

Como QC 2.0 Classe B, QC 3.0 e QC 4.0 são retrocompatíveis com QC 2.0 Classe A, este dispositivo pode funcionar com todos os carregadores/power banks mais recentes. As opções de tensão serão 5V, 9V e 12V. Se outras tensões forem necessárias, consulte os datasheets CHY 100, 101, 103 e modifique o código.

⚠️ Avisos Importantes

• Use apenas Power Bank ou Carregador QC de alta qualidade com Proteção contra Curto-Circuito. Cargas externas não devem exceder 18 Watts. Verifique a etiqueta de potência dos dispositivos.
• Evite saída de 20 Volts, pois o regulador LM1117 3.3V suporta no máximo 15V. Isso deve ser evitado no código do MCU nunca permitindo que D+ e D- tenham 3.3V simultaneamente.
• Caso necessite de 20V (suportado por QC 2.0 Classe B, QC 3.0, QC 4.0), use um regulador (ex: LM317 configurado para 3.3V) que suporte mais de 20V. Caso contrário, tanto o regulador quanto o MCU serão destruídos!
• Atente à polaridade da saída: + indicado por fio vermelho, – por fio azul próximo ao terminal de saída.
• Evite conexões frouxas no acoplamento USB Macho-Fêmea, pois geram calor por resistência de contato e reduzem a eficiência.
• Durante programação ISP, todos os jumpers devem ser removidos para isolar pinos MOSI, MISO, SCK, VCC, GND, RESET do resto do circuito e evitar interferência.
• Não modifique o código sem entender claramente o protocolo QC. Este design é principalmente para fontes QC 2.0 (Classe A), mas pode ser parcialmente usado para padrões superiores.
• O hack pode não funcionar com alguns carregadores/power banks QC.
• A comutação dos GPIOs deve seguir a sequência correta para evitar a terminação do modo de alta tensão.

Nota: É aconselhável não replicar este projeto se os pontos acima não forem compreendidos, pois risco de incêndio ou perda de equipamento pode ocorrer!

É possível alterar as tensões manualmente sem microcontrolador. Apenas 4 jumpers são necessários para imitar as condições da tabela D+/D- conectando a Vcc (3.3V) e GND (0V) aos resistores na sequência correta. Usar MCU pode ser overkill para transições tão simples.

Referências

• Datasheet família CHY
• Wikipedia Quick Charge
• Guia Texas Instruments

Código

Código ATtiny85 (C/C++)

///========================= Algoritmo ========================/// 
/* Primeiro, conecte o pino D+ a uma tensão de 0.325 a 2 volts e mantenha D- flutuante, espere pelo menos 2 segundos. 
Duas ações ocorrem durante esses 2 segundos: 
1. D+ e D- igualam uma tensão entre 0.325 a 2 volts por 1.25 segundos (porque D+ e D- conectam-se internamente no CHY100 inicialmente). 
2. D+ mantém a tensão entre 0.325 a 2 volts e D- cai para zero (porque D+ e D- desconectam e um resistor interno no CHY100 descarrega D-).
*** CHY100 é um chip de interface de protocolo QC 2.0 dentro do power bank/carregador ... outros chips QC 2.0 são provavelmente similares.
Faça D+ acima de 3.0V primeiro e então conecte D- a uma tensão entre 0.325 a 2 volts. O VBUS salta para 9V.
Mantendo D- conectado a uma tensão entre 0.325 a 2 volts, faça D+ uma tensão entre 0.325 a 2 volts. O VBUS salta para 12V (porque D+ e D- estão entre 2V e 0.325V).
Desconecte D+ da tensão entre 0.325 a 2 volts. VBUS volta a 5V, porque o QC2.0 sai do modo de mudança de tensão e VBUS retorna ao padrão 5V.
Recomece do início quando precisar entrar no QC2.0 novamente).
*/
// ============ NOTA IMPORTANTE ================
// *** A sequência de colocar pinos HIGH e LOW é importante
// *** Se D+ cair abaixo de 0.325V durante a transição por sequência errada de GPIO
// *** QC 2.0 sairá do Modo Alta Tensão e VBUS retornará a 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);
  // Iniciando Handshake QC colocando D+ em 0.6V mantendo D- em 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();
}

///********************** Funções **********************///
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);
  // agora protocolo QC está ativo
}

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() {
  // Troque o Regulador de Tensão !!!
  // Por sua conta e risco
}

Esquemático

Circuito no circuits.io