Explícate bastante mejor, con ejemplos por pasos y dibujos, a ser posible.

Sí, se me ha ocurrido algo.

Mediante desplazamiento de bits y AND puedes sacar uno a uno los bits de cada carácter.
Por otra parte hay 4 formas diferentes de rellenar los rectángulos con esos bits, por tanto prepararía 4 funciones diferentes que recibieran los siguientes argumentos: posición X, dentro de QR de su primer bit; posición Y, dentro de QR de su primer bit; carácter que debe codificar. La función retornará la posición X e Y calculada después de que este 'cursor' salga del recuadro (que será usado por la siguiente función para escribir el siguiente carácter).

Ejemplo de uso de esas funciones, la implementación te la dejo para tí:

Dentro de cada función, mediante AND y desplazamientos a la derecha >> puedes sacar cada bit para saber en esa posición del QR hay un 1 o un 0.
Como todas las funciones son parecidas, solo cambia el patrón de movimiento, puedes hacerlo todo en una única función y que el patrón se de como un argumento más. Por ejemplo:
void writedata(int *x, int *y, char *c, PATH p);
Siendo PATH un enum con los cuatro caminos diferentes que pueden tomar los datos.

Si nunca has usado ese operador puedes usar x /= 2. Al dividir un número por dos estás desplazando una vez a la derecha ese número (a nivel de bits).

Pero bueno, si explicas hasta donde has llegado en C tal vez podamos ajustar la respuesta a tus conocimientos.

Veo, por otros mensajes, que sigue sin salirte. Sin saber como se trabaja a nivel de bits no podrás resolver este problema.

Te paso un código que he realizado que solo realiza hasta la codificación de la cadena e imprime los recuadros de posición.

El programa es básico pues se puede optimizar bastante más, pero para mejorar la sencillez te lo dejo así, está comentado. Espero que te sirva:

#include <stdio.h>
#include <string.h> // strlen
#include <ctype.h> // isprint
 
#define tamQR 21
#define info "www.elhacker.net"
 
// Ya que la tabla QR es el objeto principal de este programa
// lo hago global, para ahorrarme trabajo con las funciones.
// Cada posición x y guardará un 0, si no ese bit no debe estar
// activo o un valor distino a 0 si ese bit debe tener información.
int QR[tamQR][tamQR];
 
// Nota: Voy a llamar cursor a la posición x e y dentro del QR
// donde se vaya a escribir un dato.
 
// Una ayuda para manejar las cosas dentro de las funciones
typedef enum {
    ABAJO,
    ARRIBA,
    DESDE_ABAJO,
    DESDE_ARRIBA
} DIRECCION;
 
// --------------------------------------------------------------
// TODO ESTO NO CODIFICA TUS BYTES, SOLO REPRESENTA EL
// DIBUJO BÁSICO DEL QR
// Crea el cuadrado exterior de los recuadros de posición
void cuadrado_exterior(int x, int y) {
    // Variables auxiliares para mover el cursor
    // de dibujo por todo el recuadro
    int xc, yc;
 
    // Dibujo las líneas horizontales superior e inferior
    for(xc = x; xc < x+7; ++xc) {
        QR[y][xc] = 1;
        QR[y+6][xc] = 1;
    }
 
    // Dibujo las líneas verticales
    for(yc = y; yc < y+6; ++yc) {
        QR[yc][x] = 1;
        QR[yc][x+6] = 1;
    }
}
 
// Crea el cuadrado interior de los recuadros de posición
void cuadrado_interior(int x, int y) {
    int xc, yc;
 
    for(yc = y; yc < y+3; ++yc)
        for(xc = x; xc < x+3; ++xc)
            QR[yc][xc] = 1;
}
 
// La función que se debe llamar para dibujar los cuadrados
// pasándole la posición de la esquina superior izquierda
void cuadrado(int x, int y) {
    cuadrado_exterior(x, y);
    cuadrado_interior(x+2, y+2);
}
 
void QR_inicializar() {
    int x, y;
 
    // Borrar todo el QR
    for(y = 0; y < tamQR; ++y)
        for(x = 0; x < tamQR; ++x)
            QR[y][x] = 0;
 
    // Escribir en el los recuadros de posición
	cuadrado(0, 0);
	cuadrado(14, 0);
	cuadrado(0, 14);
}
 
void QR_imprimir() {
    int x, y;
 
    // Se escribirá el carácter 219 o el 176 en la consola
    // según si QR[y][x] es no 0 o 0 respectivamente
    for(y = 0; y < tamQR; ++y) {
        for(x = 0; x < tamQR; ++x) {
            char c = QR[y][x]? 219:176;
            printf("%c", c);
        }
        printf("\n");
    }
}
// --------------------------------------------------------------
 
// La idea es que solo hay dos caminos que se repiten de cada grupo de
// cuatro bits:
//  De abajo a arriba (4 pasos)
//    1) ..   2) ..  3) .o  4) o.
//       .o      o.     ..     ..
//
//  De arriba a abajo (4 pasos)
//    1) .o   2) o.  3) ..  4) ..
//       ..      ..     .o     o.
//
// A cada posición le corresponde un bit del nibble (grupo de 4 bits)
// desde el bit de mayor peso al bit de menor peso.
// Además se dejará el cursor a la siguiente posición (la que seguiría
// el patrón si hubiera continuado una vez más) dejándolo preparado
// para que el próximo nibble se escriba en él sin hacer más cálculos
// (cómo se vera esto se consigue de forma natural con el bucle).
void codificar_nibble(int *x, int *y, char nibble, DIRECCION partida) {
    // La máscara sirve para para conseguir trabajar con los bits
    // que quieres dentro de un dato (si eso búscalo en Google para
    // comprender más). En este caso como es un nibble (conjunto de 4 bits)
    // el bit de mayor peso, dentro de un byte está aquí 00001000 en binario
    // (que es igual a 8 decimal).
    char mascara = 8;
    // La bandera cambiará entre falso (0) y cierto (no 0) para controlar el
    // cursor, si debe ir en una dirección u otra.
    int bandera = 0;
 
    // El desplazamiento de bits sobre la máscara (busca que es eso) irá
    // desplazando el 1 hacia la derecha hasta que mascara tendrá todo 0,
    // momento en que mascara valdrá 0 en decimal y el while se detendrá.
    while(mascara) {
        // Escribe donde se encuentre el cursor el dato del bit mascara
        // del nibble
        QR[*y][*x] = nibble & mascara;
        // Muevo el bit de la mascara un lugar a la derecha
        mascara >>= 1;
 
        // Actualizo el cursor para la siguiente posición
        switch(partida) {
            case ABAJO:
                // No se necesita. Usado para evitar el warning del compilador.
                break;
 
            case ARRIBA:
                // No se necesita. Usado para evitar el warning del compilador.
                break;
 
            // Sacado de tus dibujos
            case DESDE_ABAJO:
                if(!bandera)
                    --*x; // A la izquierda
                else {
                    ++*x; // A la derecha
                    --*y; // y a arriba
                }
                break;
 
            case DESDE_ARRIBA:
                if(!bandera)
                    --*x; // A la izquierda
                else {
                    ++*x; // A la derecha
                    ++*y; // Y abajo
                }
                break;
        }
        bandera = !bandera;
    }
}
 
void codificar_byte(int *x, int *y, unsigned char c, DIRECCION direcc) {
    // La siguiente línea tan solo es para depuración. No es necesaria para
    // crear el QR
    printf("x: %2i, y: %2i, c: %3i ( %c )\n", *x, *y, c, isprint(c)? c : ' ');
 
    // Cada byte se compone de 2 nibbles.
    // La expresión c>>4 & 0xF toma los cuatro bits de más peso del byte.
    // La expresión c & 0xF toma los cuatro bits de menos peso del byte.
    // (En verdad, todo esto del trabajo con bits es necesario para hacer
    // este ejercicio).
    switch(direcc) {
        case ABAJO:
            codificar_nibble(x, y, c>>4 & 0xF, DESDE_ARRIBA);
            codificar_nibble(x, y, c & 0xF, DESDE_ARRIBA);
            break;
 
        case ARRIBA:
            codificar_nibble(x, y, c>>4 & 0xF, DESDE_ABAJO);
            codificar_nibble(x, y, c & 0xF, DESDE_ABAJO);
            break;
 
        case DESDE_ABAJO:
            codificar_nibble(x, y, c>>4 & 0xF, DESDE_ABAJO);
            *x -= 2; // Estas dos expresiones para actualizar el cursor son necesarias
            ++*y;    // pues donde lo deja la función codificar_nibble solo sirve para
                     // ABAJO y ARRIBA. Si miras tu dibujo lo comprenderás
            codificar_nibble(x, y, c & 0xF, DESDE_ARRIBA);
            break;
 
        case DESDE_ARRIBA:
            codificar_nibble(x, y, c>>4 & 0xF, DESDE_ARRIBA);
            *x -= 2; // Ídem al caso anterior
            --*y;
            codificar_nibble(x, y, c & 0xF, DESDE_ABAJO);
            break;
    }
}
 
void codificar_cadena(char *cadena) {
     size_t tam = strlen(cadena); // Tamaño de la cadena.
     int x = 20; // Posición de inicio. Se necesita meter en una variable.
     int y = 14; // porqué las mismas funciones lo irán actualizando.
     int pos = 0; // Serve para indicar qué caracter de la cadena estamos operando.
     int i;
 
     if(tam > 17) tam = 17; // Limitar el tamaño de la cadena a los 17 caracteres inicales.
 
     // Se codifican los caracteres dentro del QR
     for(i = 0; i < 2; ++i) {
         codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ARRIBA);
         codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, DESDE_ABAJO);
         codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ABAJO);
         codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ABAJO);
         codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, DESDE_ARRIBA);
         codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ARRIBA);
     }
     codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ARRIBA);
     codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ARRIBA);
     --y; // Necesario para saltar una línea de bits (ver tu dibujo)
     codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ARRIBA);
     codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, DESDE_ABAJO);
     codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ABAJO);
}
 
int main() {
	QR_inicializar();
	codificar_cadena(info);
	QR_imprimir();
 
	return 0;
}