Skip to content

Generador de fuentes LCD y OLED (bitmap a array C)

Convierte texto en chino o en inglés e imágenes en arrays C para SSD1306, SH1106, ST7920 y Adafruit GFX. Fuentes pixel nítidas de 12×12 y 16×16, los 4 modos de escaneo de PCtoLCD2002 y un decodificador.

Sin rastreo Se ejecuta en el navegador Gratis
Todo se ejecuta en tu navegador: el texto y las imágenes nunca salen de este dispositivo.

Compatible con la memoria por páginas de SSD1306 / SSD1309 / SH1106 / ST7565 y con MicroPython framebuf.MONO_VLSB: escribe los bytes directamente en la pantalla.

Vista previa

Haz clic en un píxel para invertirlo.
    6 glifo(s) · 96 bytes
    Referencia: el carácter 中 (16 × 16) en cada dirección de escaneo

    Píxel encendido = 1, glifo de GNU Unifont. Compara estos bytes con tu array para saber con qué ajustes se generó.

    Dirección de escaneo Orden de bits Bytes (hex)
    Fila a fila (bytes horizontales) MSB primero: primer píxel en el bit 7 01 00 01 00 01 00 01 00 3F F8 21 08 21 08 21 08 21 08 21 08 3F F8 21 08 01 00 01 00 01 00 01 00
    Fila a fila (bytes horizontales) LSB primero: primer píxel en el bit 0 80 00 80 00 80 00 80 00 FC 1F 84 10 84 10 84 10 84 10 84 10 FC 1F 84 10 80 00 80 00 80 00 80 00
    Columna a columna (bytes verticales) MSB primero: primer píxel en el bit 7 00 00 00 00 0F F0 08 20 08 20 08 20 08 20 FF FF 08 20 08 20 08 20 08 20 0F F0 00 00 00 00 00 00
    Columna a columna (bytes verticales) LSB primero: primer píxel en el bit 0 00 00 00 00 F0 0F 10 04 10 04 10 04 10 04 FF FF 10 04 10 04 10 04 10 04 F0 0F 00 00 00 00 00 00
    Columnas por página (bytes verticales, orden de páginas SSD1306) MSB primero: primer píxel en el bit 7 00 00 0F 08 08 08 08 FF 08 08 08 08 0F 00 00 00 00 00 F0 20 20 20 20 FF 20 20 20 20 F0 00 00 00
    Columnas por página (bytes verticales, orden de páginas SSD1306) LSB primero: primer píxel en el bit 0 00 00 F0 10 10 10 10 FF 10 10 10 10 F0 00 00 00 00 00 0F 04 04 04 04 FF 04 04 04 04 0F 00 00 00
    Filas por franja (bytes horizontales, franjas de 8 píxeles) MSB primero: primer píxel en el bit 7 01 01 01 01 3F 21 21 21 21 21 3F 21 01 01 01 01 00 00 00 00 F8 08 08 08 08 08 F8 08 00 00 00 00
    Filas por franja (bytes horizontales, franjas de 8 píxeles) LSB primero: primer píxel en el bit 0 80 80 80 80 FC 84 84 84 84 84 FC 84 80 80 80 80 00 00 00 00 1F 10 10 10 10 10 1F 10 00 00 00 00

    Fuentes pixel: GNU Unifont (16 px) y Fusion Pixel Font (12 px), ambas bajo la SIL Open Font License 1.1. Textos de las licencias

    Las ocho combinaciones de dirección de escaneo y orden de bits se comprueban byte a byte contra una implementación de referencia independiente, y los presets contra las datasheets del SSD1306, SH1106 y ST7565 y el código fuente de Adafruit GFX, U8g2, LVGL y MicroPython. — Equipo Go Tools · Oct 3, 2026

    Creado y verificado por el equipo de ingeniería de Go Tools.

    Respuestas rápidas

    ¿Qué ajustes necesita un OLED SSD1306?

    Columnas por página · LSB primero Columnas por página, LSB primero, píxel encendido = 1, cuando escribes los bytes directamente en la memoria de la pantalla.

    ¿Qué ajustes necesita Adafruit GFX drawBitmap()?

    Fila a fila · MSB primero Fila a fila, MSB primero, píxel encendido = 1, con cada fila rellenada hasta bytes enteros.

    ¿Cuántos bytes ocupa un carácter de 16 × 16?

    32 bytes 32 bytes en cualquier dirección de escaneo. Un 12 × 12 ocupa 24 bytes y un carácter ASCII de 8 × 16, 16.

    ¿Qué significan 顺向 y 逆向 en PCtoLCD2002?

    逆向 = LSB primero 顺向 («sentido directo») = MSB primero (primer píxel en el bit 7); 逆向 («sentido inverso») = LSB primero (primer píxel en el bit 0).

    ¿Qué es el bitmap de una fuente (取模)?

    La mayoría de los controladores gráficos OLED y LCD —entre ellos el SSD1306, el SH1106 y el ST7565— no tienen fuente integrada. Para mostrar un carácter, el firmware copia en la memoria de la pantalla una pequeña rejilla de píxeles encendidos o apagados: un bit por píxel, ocho píxeles por byte. Convertir un glifo en esos bytes es lo que los tutoriales chinos de sistemas embebidos llaman 取模 («sacar el modelo» del carácter), la tarea que el programa de Windows PCtoLCD2002 lleva años haciendo.

    Los bytes por sí solos no bastan. El mismo carácter de 16 × 16 puede empaquetarse de cuatro formas (fila a fila, columna a columna, columnas por página, filas por franja) y cada una puede poner el primer píxel en el bit 7 o en el bit 0. Ocho secuencias de bytes describen el mismo glifo y una pantalla solo dibuja bien una de ellas. Por eso una fuente copiada de un tutorial aparece tan a menudo en espejo, partida por la mitad o girada.

    // 中 (16x16), pages of columns, LSB first, lit = 1 — SSD1306 page order
const unsigned char zhong[32] = {
  0x00,0x00,0xF0,0x10,0x10,0x10,0x10,0xFF,0x10,0x10,0x10,0x10,0xF0,0x00,0x00,0x00,
  0x00,0x00,0x0F,0x04,0x04,0x04,0x04,0xFF,0x04,0x04,0x04,0x04,0x0F,0x00,0x00,0x00
};
// First 16 bytes = page 0 (rows 0-7), one byte per column, bit 0 = top row

    Qué hace este generador

    Chino de 12 × 12 y 16 × 16 perfecto al píxel

    Las fuentes del navegador son contornos con antialiasing; al umbralizarlas a 12 px en una tipografía Song, los trazos horizontales de 中 simplemente desaparecen. Por eso esta herramienta incluye fuentes bitmap reales: la de 16 × 16 cubre los 6.763 caracteres de GB2312, mientras que a la de 12 × 12 le faltan 143 poco comunes, que se dibujan con una fuente del sistema y quedan señalados.

    Los cuatro modos de escaneo de PCtoLCD2002, en ambos órdenes de bits

    Fila a fila, columna a columna, columnas por página y filas por franja, cada uno con MSB primero o LSB primero y píxel encendido = 1 o 0. Los nombres de las opciones siguen a PCtoLCD2002 y su significado se ha contrastado con la datasheet del SSD1306 y con proyectos de ejemplo OLED habituales, así que puedes elegir la misma configuración que usa un proyecto existente.

    Presets que dicen con qué son compatibles

    Elige SSD1306, Adafruit GFX o XBM y las opciones se ajustan solas. Si cambias una opción a mano, la herramienta te dice qué pantallas y librerías leen ese orden de bytes, o que ninguna lo hace.

    Decodifica un array que ya tienes

    Pega un array de fuente de origen desconocido y se dibujan en paralelo las ocho lecturas posibles de escaneo y orden de bits. La que se lee bien te da los ajustes; un clic los aplica.

    Imagen a bitmap con dithering de verdad

    Logos, iconos y fotos se escalan al tamaño de tu pantalla y se convierten con umbral, dithering Floyd–Steinberg o Atkinson. Las zonas transparentes cuentan como fondo y el umbral funciona en todos los modos.

    Salida lista para tu proyecto

    Arrays 2D estilo C51 con comentarios /*"中",0*/, Arduino PROGMEM con offsets, diccionarios bytearray de MicroPython, líneas DB de A51 o hexadecimal plano. El C generado compila limpio con -Wall -Wextra -pedantic.

    Ejemplos resueltos

    中 para un OLED SSD1306 (16 × 16, columnas por página, LSB primero)

    中
    00 00 F0 10 10 10 10 FF 10 10 10 10 F0 00 00 00 00 00 0F 04 04 04 04 FF 04 04 04 04 0F 00 00 00

    32 bytes: las 16 columnas de la página 0 (filas 0–7) y después las 16 columnas de la página 1 (filas 8–15). En el 0xFF de la columna 7 están todos los bits activos: el trazo vertical recorre las ocho filas de ambas páginas.

    El mismo 中 para Adafruit GFX drawBitmap (fila a fila, MSB primero)

    中
    01 00 01 00 01 00 01 00 3F F8 21 08 21 08 21 08 21 08 21 08 3F F8 21 08 01 00 01 00 01 00 01 00

    Dos bytes por fila, 16 filas. 0x01 0x00 es solo el trazo central: el píxel más a la izquierda es el bit 7 del primer byte, así que el píxel de la columna 7 cae en el bit 0. Si mandas estos bytes a un SSD1306 con escritura por páginas, sale basura: el mismo glifo, otro empaquetado.

    A de media anchura en una fuente de 16 píxeles (8 × 16)

    A
    00 00 00 00 18 24 24 42 42 7E 42 42 42 42 00 00

    Los caracteres ASCII son de media anchura: 8 × 16 son 16 bytes, un byte por fila al escanear fila a fila. Marca «Dar a los caracteres de media anchura el ancho completo de la celda» si tu driver espera que todos los glifos sean de 16 × 16.

    Por qué 12 × 12 son 24 bytes y no 18

    中 (12 × 12, fila a fila, MSB primero)
    00 00 04 00 04 00 FF E0 84 20 84 20 84 20 FF E0 04 00 04 00 04 00 04 00

    Cada fila de 12 píxeles necesita dos bytes; los cuatro últimos bits del segundo byte son relleno. 12 filas × 2 bytes = 24. Todas las librerías de pantalla direccionan las filas como (ancho + 7) / 8 bytes, así que empaquetar los bits más juntos las rompería a todas.

    Cómo generar datos de fuente para un LCD u OLED

    1. 1

      Escribe texto o arrastra una imagen

      El texto usa una fuente pixel de verdad: 12 × 12 (Fusion Pixel) o 16 × 16 (GNU Unifont), con el ASCII a media anchura. Para logos e iconos, cambia a la pestaña Imagen y fija el tamaño de destino, por ejemplo 128 × 64.

    2. 2

      Elige la pantalla o librería de destino

      SSD1306 / SH1106 / ST7565 necesitan bytes verticales en orden de página, con el píxel superior en el bit 0. Adafruit GFX, TFT_eSPI, U8g2 drawBitmap y LVGL necesitan bytes horizontales con el píxel izquierdo en el bit 7. XBM / U8g2 drawXBM es igual, pero con el píxel izquierdo en el bit 0.

    3. 3

      Revisa la vista previa y corrige píxeles si hace falta

      La vista previa muestra exactamente el bitmap que se codifica. Haz clic en cualquier píxel para invertirlo, o desplaza el glifo con los campos de desplazamiento.

    4. 4

      Copia o descarga

      Elige C (estilo C51 de PCtoLCD2002), Arduino PROGMEM, bytearray de MicroPython, ensamblador A51 o hexadecimal plano. La primera línea de la salida registra la dirección de escaneo, el orden de bits y el tamaño del glifo, así que el array se documenta solo.

    Caracteres ilegibles: síntoma → ajuste incorrecto

    Cada grupo de 8 píxeles sale en espejo horizontal

    Bytes horizontales con el orden de bits equivocado. Adafruit GFX drawBitmap() necesita MSB primero; XBM y U8g2 drawXBM() necesitan LSB primero.

    ✗ Incorrecto 
    U8g2 drawXBM() recibe bytes con MSB primero
    ✓ Correcto 
    drawXBM() → preset XBM (fila a fila, LSB primero)

    Cada bloque de 8 filas sale al revés

    Bytes verticales con el orden de bits equivocado. Los controladores tipo SSD1306 ponen D0 en la fila superior, así que necesitan LSB primero.

    ✗ Incorrecto 
    Columnas por página, MSB primero → SSD1306
    ✓ Correcto 
    Columnas por página, LSB primero → SSD1306

    Mitades superior e inferior intercaladas

    Se han confundido columna a columna y columnas por página. Solo dan los mismos bytes con glifos de hasta 8 píxeles de alto; a 16 píxeles, el orden de los bytes cambia.

    ✗ Incorrecto 
    Columna a columna → escrituras por páginas del SSD1306
    ✓ Correcto 
    Columnas por página → escrituras por páginas del SSD1306

    Glifo volteado sobre su diagonal, o invertido

    Un volteo diagonal significa que se leyeron bytes horizontales como verticales (o al revés). Texto oscuro sobre fondo encendido significa que se eligió encendido = 0 donde la pantalla espera encendido = 1.

    ✗ Incorrecto 
    Bytes fila a fila enviados a una página del SSD1306
    ✓ Correcto 
    Pega el array en la pestaña del decodificador y elige la vista previa legible

    Cuándo lo necesitas

    Texto en chino en un OLED SSD1306 de 0,96"
    Una lectura de temperatura, un menú o una línea de estado en chino en una placa STM32 o 51. Usa la fuente de 16 × 16 con el preset SSD1306 y pega el array en el oled_font.h que ya trae tu proyecto de ejemplo.
    Logo de arranque en una pantalla Arduino o ESP32
    Arrastra un logo PNG, fija 128 × 64, elige el preset Adafruit GFX y llama a display.drawBitmap(0, 0, logo, 128, 64, WHITE).
    Iconos y unidades para una interfaz LVGL o U8g2
    Símbolos de batería, Wi-Fi y °C como imágenes de 1 bit. Usa el preset Adafruit GFX / LVGL para bytes horizontales con MSB primero, o el preset XBM para U8g2 drawXBM().
    Trabajar desde Mac o Linux
    PCtoLCD2002 y las clásicas herramientas de 字模提取 son programas de Windows. Esta funciona en cualquier navegador moderno y no requiere instalación.
    Ingeniería inversa de un proyecto heredado
    El desarrollador anterior dejó un array Hzk[][32] sin ninguna nota. Pégalo en el decodificador para averiguar cómo se generó antes de añadir caracteres nuevos en el mismo formato.

    Cómo funcionan las cuatro direcciones de escaneo

    Fila a fila (bytes horizontales)
    Las filas se toman de arriba abajo; dentro de una fila, cada byte guarda ocho píxeles contiguos de izquierda a derecha. Una fila de 16 píxeles son dos bytes. Es la disposición de Adafruit GFX drawBitmap(), U8g2 drawBitmap(), los archivos XBM, la GDRAM del ST7920 y las imágenes de 1 bit de LVGL.
    Columnas por página (bytes verticales): el orden del SSD1306
    El glifo se corta en páginas de ocho filas de alto. En cada página, las columnas se toman de izquierda a derecha y cada byte guarda los ocho píxeles de esa columna. Coincide con la GDDRAM del SSD1306, SH1106 y ST7565, cuya datasheet indica que el bit de datos D0 se escribe en la fila superior; por tanto, el orden de bits que encaja es LSB primero.
    Columna a columna, y filas por franja
    Columna a columna recorre cada columna de arriba abajo por todas las páginas antes de pasar a la derecha; coincide con el modo de direccionamiento vertical del SSD1306. Filas por franja toma una franja de 8 píxeles de ancho, todas sus filas, y luego la franja siguiente; ninguna librería habitual lo usa, pero sí proyectos antiguos de PCtoLCD2002. Cada modo solo da el mismo resultado que su pareja cuando el glifo mide como mucho 8 píxeles de alto (o de ancho), y por eso la confusión pasa desapercibida en las pruebas con 8 × 8.
    Orden de bits y valor del píxel encendido
    MSB primero pone el primer píxel tomado (el de más a la izquierda, o el de más arriba) en el bit 7; LSB primero lo pone en el bit 0. PCtoLCD2002 los llama 顺向 («sentido directo», MSB primero) y 逆向 («sentido inverso», LSB primero). Encendido = 1 (阴码) es lo que esperan los OLED, drawBitmap() en TFT y LVGL A1; encendido = 0 (阳码) solo para drivers que definen 0 como encendido.
    Relleno cuando el tamaño no es múltiplo de 8
    Cada fila (bytes horizontales) o cada página (bytes verticales) se rellena por separado hasta completar bytes enteros, y los bits de relleno son 0. Con columnas por página y un glifo de 12 píxeles, la segunda página lleva 4 filas de relleno; un driver que escribe páginas completas borra esas 4 filas bajo el glifo. La herramienta avisa cuando ocurre.

    Acertar a la primera

    Elige el preset por la función de dibujo, no por la pantalla
    Un SSD1306 controlado con Adafruit_SSD1306 pasa por drawBitmap(), así que necesita bytes horizontales con MSB primero aunque la memoria del propio controlador sea vertical. Elige el preset que corresponda a la función que llama tu código.
    Usa las fuentes pixel para 12 y 16 px
    Por debajo de unos 20 px, las fuentes vectoriales pierden trazos al umbralizarlas. Fusion Pixel 12 y Unifont 16 están dibujadas sobre la rejilla de píxeles, y las opciones 2× dan 24 × 24 y 32 × 32 limpios.
    Conserva el comentario de cabecera
    La primera línea de la salida registra la dirección de escaneo, el orden de bits y el tamaño. Seis meses después, es lo único que dice cómo se generó el array.
    Prueba con un carácter asimétrico
    Los glifos simétricos como 中, 田 o H esconden los errores de espejo. Prueba primero con F, 7 o 乙: si se ve bien, todas las opciones son correctas.
    Corrige el espejado de toda la pantalla en el driver
    Si todo lo que hay en pantalla sale en espejo o al revés, y no solo tu fuente, cambia el segment remap (A0h/A1h) y la dirección de escaneo COM (C0h/C8h) en la secuencia de inicialización. Tocar los ajustes de la fuente solo rompería el resto del código.

    Preguntas frecuentes

    ¿Qué ajustes debo usar para un OLED SSD1306 o SH1106?
    Si tu código escribe los bytes de la fuente directamente en la pantalla (la mayoría de los ejemplos para 51 y STM32): columnas por página, LSB primero, encendido = 1, es decir, el preset SSD1306. Si dibuja a través de Adafruit_SSD1306 o U8g2 drawBitmap(), usa en su lugar el preset Adafruit GFX, porque esas funciones leen bytes horizontales con MSB primero y hacen la conversión por su cuenta.
    Mis caracteres salen en espejo, al revés o desordenados. ¿Qué pasa?
    Cada síntoma apunta a un ajuste. Cada 8 píxeles en espejo horizontal: orden de bits equivocado con bytes horizontales. Cada 8 filas al revés: orden de bits equivocado con bytes verticales. Mitades superior e inferior intercaladas: se han confundido columna a columna y columnas por página. Volteado sobre la diagonal: se han confundido bytes horizontales y verticales. Colores invertidos: encendido = 1 y encendido = 0 intercambiados. Si lo que sale en espejo es toda la pantalla, y no solo tu texto, corrige la secuencia de inicialización del driver.
    ¿Por qué 12 × 12 ocupa 24 bytes y no 18?
    Cada fila (o cada página de 8 filas) se rellena por separado hasta bytes enteros: 12 píxeles necesitan 2 bytes, y 12 filas × 2 = 24. Las librerías de pantalla direccionan las filas como (ancho + 7) / 8 bytes, así que un glifo de 18 bytes empaquetado al máximo lo leerían mal todas ellas.
    ¿Por qué mi texto de 12 píxeles borra la línea de debajo en el OLED?
    Con columnas por página, un glifo de 12 píxeles llena una página entera y la mitad de la siguiente; los otros 4 bits de esa segunda página son ceros de relleno. Un driver que escribe páginas completas borra esas 4 filas. Dibuja a través de un frame buffer que active píxeles individuales, o coloca el texto de 12 píxeles de modo que las filas vacías caigan donde no se dibuja nada más.
    ¿Puedo usarlo en lugar de PCtoLCD2002 en un Mac?
    Sí. Funciona en cualquier navegador moderno, ofrece los mismos cuatro modos de escaneo, ambos órdenes de bits y encendido = 1 / encendido = 0, y la salida C sigue el estilo C51 de PCtoLCD2002 con comentarios /*"字",0*/, así que se pega sin más en proyectos basados en arrays tipo Hzk[][32]. No genera archivos completos de librería de fuentes ni índices. Los glifos proceden de GNU Unifont y Fusion Pixel, no de SimSun de Windows, así que los bytes no coincidirán carácter por carácter con un array generado por PCtoLCD2002: regenera aquí la tabla completa en lugar de mezclar ambos. Este sitio no está afiliado a PCtoLCD2002 ni a su autor, no es una versión web oficial y no ofrece el programa para descargar.
    ¿Por qué una fuente pixel y no la fuente de mi sistema?
    Las fuentes del sistema son contornos dibujados con antialiasing, que el navegador no puede desactivar. A 12 o 16 píxeles, umbralizar ese borde gris hace perder los trazos finos: las barras horizontales de 中 desaparecen por completo en una tipografía Song de 12 píxeles. GNU Unifont (16 px) y Fusion Pixel (12 px) están diseñadas sobre la rejilla de píxeles, así que no se pierde nada. Las fuentes del sistema siguen disponibles para tamaños mayores: una tipografía sans-serif (Hei) aguanta a partir de unos 24 px, mientras que las tipografías Song todavía pueden perder trazos a ese tamaño.
    ¿Qué caracteres cubren las fuentes pixel?
    Todo GB2312 (6.763 caracteres chinos simplificados más la puntuación de anchura completa), además de ASCII imprimible, letras latinas acentuadas (é, ß, ł, ş, ő), griego, cirílico, kana japoneses y símbolos comunes como ℃, flechas y caracteres de dibujo de cuadros. A Fusion Pixel 12 px le faltan algunos caracteres y símbolos poco frecuentes. El hangul coreano y los caracteres chinos fuera de GB2312 (formas tradicionales, muchos kanji japoneses) se dibujan con una fuente del sistema y se listan bajo la vista previa, para que veas qué glifos revisar.
    ¿Cómo convierto un logo o icono en un array C?
    Abre la pestaña Imagen, arrastra el archivo, fija el tamaño de la pantalla (128 × 64 para un OLED de 0,96") y deja «Ajustar dentro, mantener proporciones» para conservar la relación de aspecto. Los píxeles oscuros se convierten en píxeles encendidos; marca invertir si el dibujo es claro sobre fondo oscuro. Sin dithering para logos y texto; Floyd–Steinberg o Atkinson para fotos.
    ¿Cómo sé cómo se generó un array de fuente existente?
    Pégalo en la pestaña «Previsualizar un array existente». Los comentarios se ignoran y se acepta sintaxis de C, Arduino, A51 y MicroPython. El tamaño del glifo se deduce del número de bytes y se dibujan las ocho combinaciones de dirección de escaneo y orden de bits. La que se lee bien es tu configuración, y «Usar estos ajustes» la copia al generador.
    ¿Se sube mi texto o mi imagen a algún sitio?
    No. Los glifos se renderizan y codifican en tu navegador. Las fuentes pixel se descargan una sola vez desde este sitio y nada de lo que escribes o arrastras se envía a ninguna parte.

    Herramientas relacionadas

    Ver todas las herramientas →

    Conversor de Bases — Binario, Hex, Decimal, Octal

    Herramientas de Conversión

    Convierte números entre binario, hexadecimal, decimal, octal y cualquier base personalizada (2-36) al instante. Gratis, privado, sin registro — todo el procesamiento ocurre en tu navegador.

    Calculadora de complemento a dos y enteros con signo

    Herramientas de Conversión

    Escribe un entero con signo y obtén de golpe signo-magnitud, complemento a uno, complemento a dos y binario desplazado, de 4 a 64 bits. O pega un patrón de bits o un byte hexadecimal y verás las cinco lecturas.

    Calculadora chmod — Permisos de archivos Linux

    Herramientas de Conversión

    Convierte permisos de archivos Linux entre octal (755, 644) y símbolos rwx. Obtén comandos chmod y detecta ajustes de riesgo como 777 — gratis, directo en tu navegador.

    Convertidor de Color — HEX, RGB, HSL y OKLCH

    Herramientas de Conversión

    Convierta HEX a RGB, HSL, OKLCH, OKLAB y CMYK en su navegador — copie cualquier formato con un clic. Gratis, sin registro, sus colores nunca salen de la página.

    Convertir coordenadas: grados minutos segundos, UTM, GCJ-02

    Herramientas de Conversión

    Convierte coordenadas GPS en cualquier formato — grados decimales, grados minutos segundos (GMS) — a UTM, Web Mercator, GCJ-02 (AMap) y BD-09 (Baidu). Detecta lat,lng o lng,lat, lotes a CSV. En tu navegador.

    Convertidor HEX a CMYK

    Herramientas de Conversión

    Convierta colores HEX a CMYK en su navegador. Aproximación ingenua basada en sRGB para vistas previas de imprenta. Gratis, sin registro, sus colores nunca salen de la página.