Empacotador RGB para RGB565
Transforme uma cor RGB na palavra de 16 bits que uma tela TFT espera: o laranja 255, 128, 0 vira 64512, ou 0xFC00. O vermelho fica com cinco bits, o verde com seis e o azul com cinco, cortados e não arredondados. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Resistência (Ω)
- 255
- G
- 128
- B
- 0
- Rgb565
- 64.512
- Hex
- 0xFC00
- Dígitos hexadecimais
- FC00
- Bits
- 1111110000000000
Controladores TFT embarcados, bibliotecas gráficas para microcontroladores e muitos consoles portáteis guardam cada pixel como uma única palavra RGB565 de dezesseis bits, em vez de três canais de oito bits separados. Este empacotador de RGB para RGB565 recebe inteiros de vermelho, verde e azul de zero a duzentos e cinquenta e cinco e os compacta truncando os bits baixos que sobram: cinco bits de vermelho, seis de verde e cinco de azul, e em seguida monta o leiaute clássico de dezesseis bits usado por ILI9341, ST7735, ST7789, SSD1351, Adafruit GFX e TFT_eSPI. A conversão é totalmente determinística, não arredonda, não chama a rede e nunca depende do relógio.
Como o empacotamento RGB565 funciona e o que a resposta contém
No sRGB de oito bits, cada um de vermelho, verde e azul é um inteiro de zero a duzentos e cinquenta e cinco, mais precisão do que um framebuffer de dezesseis bits consegue guardar. RGB565 reserva cinco bits para o vermelho, seis para o verde e cinco para o azul porque o olho humano é mais sensível ao verde, então o bit extra é gasto onde mais reduz o bandeamento.
Este empacotador usa o truncamento padrão da indústria, não o arredondamento: o vermelho é deslocado três bits à direita, o verde dois bits à direita e o azul três bits à direita, descartando os bits baixos que sobram. Os três campos são montados como vermelho deslocado onze bits à esquerda, disjunção bit a bit com o verde deslocado cinco bits à esquerda, disjunção bit a bit com o azul, gerando um inteiro sem sinal único de zero a sessenta e cinco mil quinhentos e trinta e cinco.
Preto puro empacota para zero, branco puro para o máximo, vermelho puro vira a conhecida palavra hexadecimal F800, verde puro vira 07E0 e azul puro vira 001F. Não há envelopamento silencioso de duzentos e cinquenta e seis, nem arredondamento dos bits descartados, nem rede ou relógio no caminho, então a mesma tripla sempre produz a mesma palavra de dezesseis bits.
Como r, g e b são validados e por que o truncamento permanece honesto
Os campos preferenciais são r para vermelho, g para verde e b para azul. Espaços externos em canais de string são aparados; um sinal de mais inicial opcional só é permitido quando os caracteres restantes são dígitos decimais que se interpretam como um inteiro dentro do intervalo.
Valores como cento e vinte e oito ponto cinco falham na validação em vez de serem arredondados, e números negativos ou de duzentos e cinquenta e seis para cima falham com uma mensagem que nomeia o canal e afirma que ele precisa permanecer entre zero e duzentos e cinquenta e cinco. Campos ausentes e strings vazias depois do trim são rejeitados do mesmo jeito.
O truncamento é o contrato porque Adafruit GFX, TFT_eSPI, os exemplos da folha de dados do ILI9341 e quase toda macro de cor de Arduino descartam os bits baixos com um deslocamento à direita; um empacotador que arredondasse discordaria do firmware já em campo e quebraria testes áureos que fixam 0xF800 para o vermelho pleno.
Onde um empacotador de RGB para RGB565 se paga
Estudantes veem isso em cursos de sistemas embarcados que apresentam framebuffers TFT, em laboratórios de programação de jogos voltados a portáteis de dezesseis bits e em aquecimentos de entrevista que perguntam o leiaute de bits do RGB565.
Autores de ferramentas chamam o mesmo contrato a partir de scripts de build para semear cabeçalhos de paleta, de testes de propriedade que comparam um driver novo com este oráculo, e de pipelines de tokens de design que precisam emitir ao mesmo tempo um hex CSS e uma palavra de firmware a partir de uma única fonte da verdade.
Combine com um conversor de RGB para hex quando o próximo consumidor for uma folha de estilo, com um empacotador de RGB para inteiro decimal quando precisar de uma palavra de vinte e quatro bits, e com outras ferramentas de cor determinísticas e gratuitas ao montar um laboratório pequeno de higiene de paletas embarcadas.
Casos de uso
Paletas de firmware para TFT
Transforme triplas RGB de marca em palavras RGB565 para tabelas de cor de ILI9341, ST7735, ST7789 e Adafruit GFX.
Conversão de sprites e framebuffer
Empacote ativos offline em arrays C de 16 bits e bytes alto e baixo SPI que respeitam a ordem do controlador.
Testes determinísticos de drivers
Fixe oráculos RGB565 truncados em CI para que um novo auxiliar gráfico nunca passe em silêncio ao arredondamento.
Perguntas frequentes
Como converter RGB para RGB565?
O campo rgb565 da resposta é a palavra de 16 bits empacotada; hex é a forma de quatro dígitos com prefixo 0x usada no firmware.
Este empacotador arredonda ou trunca os bits extras?
Ele trunca. Vermelho e azul descartam seus 3 bits baixos (>> 3) e o verde descarta seus 2 bits baixos (>> 2). Isso coincide com Adafruit GFX, TFT_eSPI e os exemplos típicos de controladores TFT. Não há arredondamento.
O que acontece se um canal ficar fora de 0–255?
Os canais nunca são saturados nem envelopados, então um 256 de um seletor quebrado não vira um pixel errado.
O empacotador de RGB para RGB565 é grátis?
A ferramenta do navegador roda de graça no seu dispositivo.
Por que o verde recebe seis bits e o vermelho e o azul só cinco?
O olho humano é mais sensível ao verde, então o RGB565 gasta o bit extra ali. A divisão 5-6-5 é o leiaute de dezesseis bits usado pelos controladores TFT comuns aos quais esta ferramenta se destina.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
curl -X POST https://api.kit.forhosting.com/color/rgb-rgb565 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"r":255,"g":128,"b":0}'const res = await fetch("https://api.kit.forhosting.com/color/rgb-rgb565", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"r": 255,
"g": 128,
"b": 0
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/color/rgb-rgb565",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"r": 255,
"g": 128,
"b": 0
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/color/rgb-rgb565", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"r":255,"g":128,"b":0}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"r":255,"g":128,"b":0}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/color/rgb-rgb565", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemplo de requisição
{
"r": 255,
"g": 128,
"b": 0
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "color.rgb_rgb565",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Limites
min_channel | 0 |
max_channel | 255 |
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Canais fora de zero a duzentos e cinquenta e cinco são rejeitados com um erro invalid_input claro, em vez de serem envelopados ou saturados em silêncio.
Como o empacotamento RGB565 funciona e o que a resposta contém
A resposta ecoa os canais validados r, g e b, devolve o inteiro empacotado como rgb565, uma string hexadecimal de quatro dígitos em maiúsculas com prefixo 0x, os quatro dígitos hex sozinhos, uma string binária de dezesseis caracteres, os campos truncados r5, g6 e b5, os canais de oito bits reconstruídos r_q, g_q e b_q ao deslocar de volta à esquerda esses campos truncados, os bytes alto e baixo que uma transferência SPI para um controlador da família ILI9341 espera nessa ordem, strings CSS rgb da cor original e da quantizada, a etiqueta de método truncate_rgb565, a fórmula de bits e max sempre igual a 65535.
Como r, g e b são validados e por que o truncamento permanece honesto
Os apelidos red e R maiúsculo, green e G maiúsculo, e blue e B maiúsculo são aceitos para que planilhas, query strings e formulários tipados reutilizem o contrato sem renomear colunas. Um número JSON solto só é aceito quando é um inteiro finito entre zero e duzentos e cinquenta e cinco. Os canais reconstruídos r_q, g_q e b_q mostram a cor que de fato chega ao framebuffer depois que esses bits somem, que é a prévia honesta de que o artista precisa antes de fechar uma paleta.
Onde um empacotador de RGB para RGB565 se paga
Autores de firmware encontram esse mapeamento quando um guia de marca lista amostras RGB de oito bits e o driver do display pede uma cor uint16_t, quando uma folha de sprites é convertida offline em um array C de 16 bits, ou quando um log serial imprime uma palavra empacotada e a bancada precisa da constante hex equivalente. Nesta página o trabalho roda por completo no seu navegador; pela API cada empacotamento correto custa US$ 0,002, a validação que falha não é cobrada e nada fica armazenado depois que a resposta retorna. Essa divisão — exploração interativa gratuita e uma API paga idêntica — segue o restante do catálogo tier A do KIT e permite passar de uma demo de bancada ou de um slide de aula para um pipeline de firmware automatizado sem mudar o resultado empacotado.