Well as it happens many times, the same result can be obtained in many ways, I was shuffling several options, such as parsing the ASCII table and using the increment of 32 between uppercase and lowercase, but in the end I decided on the Use of the following:

int main(void)
{
    //Test contiene la informacion.
    char informacion[] = "010000100110100101100101011011100111011001100101011011100110100101100100011011110010000001100001001000000101001101110100011000010110001101101011010011110111011001100101011100100110011001101100011011110111011100101110";

    //Se usara para mostrar la informacion
    char *textDeco;

    int informacionLength, sim;

    //usamos strlen
    informacionLength = strlen(informacion);

    /*
    para codificar cualquier caracter ASCII en binario, 
    necesitamos al menos 7 bits, en la practica se añade 
    un octavo bit y se utiliza como bit de paridad para detectar errores
    de transmision. 
    Sin embargo, estos 8 bits (1 byte) tambien permiten representar un 
    mayor rango de caracteres puede mirar ASCII extendido
    */

    //basandonos en lo anterior hacemos estas matematicas, puesto que cada simbolo "consta"
    //de 8 (digamos un octeto, si se trabajara con bits por decirlo de alguna manera "reales o directamente") (o para este caso los 0 y 1 no son bits, sino que son representados en char osea 1 byte por cada digito) operamos y mas uno para la terminacion.

    sim = informacionLength / 8 + 1;

    //malloc
    textDeco = malloc(sim + 1);

    //Llamada a 1 de las dos funciones creadas para usar    
    binarioToText(informacion, informacionLength, sim, textDeco);

    //pues eso
    printf("La informacion contenida en ASCII: %s\n", textDeco);

    //free
    free(textDeco);

    return 0;
}

void binarioToText(char *informacionBin, int informacionLength, int sim, char *text ){

        int a;

        for(a = 0; a < informacionLength; a += 8, informacionBin += 8){

            char *byte = informacionBin;

            //Arimetica de punteros
            //*(byte+8) = '
unsigned long binarioToDecimal(char *binario, int length){

        int a;

        unsigned long decimal = 0;
        unsigned long peso = 1;

        binario += length - 1;
        peso = 1;

        //Vamos a recorrer el for tantas veces como indique length,
        //nada nuevo, pero tener encuenta que binario decrece,
        //el numero de bytes de su tipo de datos

        //saltamos hacia atras el tamaño de char "8" porque aunque 8 bits, son ocho digitos "01",
        //un byte, un char son "8" osea que 8 representa uno que es un simbolo digamos 0 o 1, al
        //al ser un char donde esta almacenado y no se esta accediendo a los "bit puros realmente".

        //se envia un length de 8, que simulan los 8 bits, pero realmente al ser caracteres no son
        //1 byte sino 8 * 1.

        for(a = 0; a < length; ++a, --binario){

            if(*binario == '1'){
                decimal += peso;
            }

            //
            peso *= 2;
        }

        return decimal;
    }
';

            //azucar para lo anterior
            byte[8] = '
Binario                     Decimal

01010101                  =  X?

1 peso                * 1 = 1 (es uno con lo que se suma) 
2 (doblamos peso)     * 0 = 0 (no es uno con lo que no se suma)
4 (doblamos)          * 1 = 4 (es uno con lo que se suma)
8 (doblamos)          * 0 = 0 (no es uno con lo que no se suma)
16(doblamos anterior) * 1 = 16(es uno con lo que se suma)
32 ...                * 0 = 0 (no es uno con lo que no se suma)
64 ...                * 1 = 64(es uno con lo que se suma)
128 ...               * 0 = 0 (no es uno con lo que no se suma)

resultado = 1 + 4 + 16 + 64 = 85
';

            //lo que nos retorna lo añadimos y asi hasta leer enviar toda la informacion
            *text ++ = binarioToDecimal(byte, 8);
        }

        //text -= sim;
    }

I think this is the most delicate part, not because it is difficult, but because I do not know if I will express myself in the simplest and most appropriate way.

#include <stdio.h>
#include <string.h>

unsigned long binarioToDecimal(char *binario, int length){

        int a;

        unsigned long decimal = 0;
        unsigned long peso = 1;

        binario += length - 1;
        peso = 1;

        //Vamos a recorrer el for tantas veces como indique length,
        //nada nuevo, pero tener encuenta que binario decrece,
        //el numero de bytes de su tipo de datos

        //saltamos hacia atras el tamaño de char "8" porque aunque 8 bits, son ocho digitos "01",
        //un byte, un char son "8" osea que 8 representa uno que es un simbolo digamos 0 o 1, al
        //al ser un char donde esta almacenado y no se esta accediendo a los bit puros realmente.

        //se envia un length de 8, que simulan los 8 bits, pero realmente al ser caracteres no son
        //1 byte sino 8 * 1.

        for(a = 0; a < length; ++a, --binario){

            if(*binario == '1'){
                decimal += peso;
            }

            //
            peso *= 2;
        }

        return decimal;
    }

    void binarioToText(char *informacionBin, int informacionLength, int sim, char *text ){

    int a;

    for(a = 0; a < informacionLength; a += 8, informacionBin += 8){

        char *byte = informacionBin;

        //Arimetica de punteros
        //*(byte+8) = '
int main(void)
{
    //Test contiene la informacion.
    char informacion[] = "010000100110100101100101011011100111011001100101011011100110100101100100011011110010000001100001001000000101001101110100011000010110001101101011010011110111011001100101011100100110011001101100011011110111011100101110";

    //Se usara para mostrar la informacion
    char *textDeco;

    int informacionLength, sim;

    //usamos strlen
    informacionLength = strlen(informacion);

    /*
    para codificar cualquier caracter ASCII en binario, 
    necesitamos al menos 7 bits, en la practica se añade 
    un octavo bit y se utiliza como bit de paridad para detectar errores
    de transmision. 
    Sin embargo, estos 8 bits (1 byte) tambien permiten representar un 
    mayor rango de caracteres puede mirar ASCII extendido
    */

    //basandonos en lo anterior hacemos estas matematicas, puesto que cada simbolo "consta"
    //de 8 (digamos un octeto, si se trabajara con bits por decirlo de alguna manera "reales o directamente") (o para este caso los 0 y 1 no son bits, sino que son representados en char osea 1 byte por cada digito) operamos y mas uno para la terminacion.

    sim = informacionLength / 8 + 1;

    //malloc
    textDeco = malloc(sim + 1);

    //Llamada a 1 de las dos funciones creadas para usar    
    binarioToText(informacion, informacionLength, sim, textDeco);

    //pues eso
    printf("La informacion contenida en ASCII: %s\n", textDeco);

    //free
    free(textDeco);

    return 0;
}
';

        //azucar para lo anterior
        byte[8] = '
void binarioToText(char *informacionBin, int informacionLength, int sim, char *text ){

        int a;

        for(a = 0; a < informacionLength; a += 8, informacionBin += 8){

            char *byte = informacionBin;

            //Arimetica de punteros
            //*(byte+8) = '
unsigned long binarioToDecimal(char *binario, int length){

        int a;

        unsigned long decimal = 0;
        unsigned long peso = 1;

        binario += length - 1;
        peso = 1;

        //Vamos a recorrer el for tantas veces como indique length,
        //nada nuevo, pero tener encuenta que binario decrece,
        //el numero de bytes de su tipo de datos

        //saltamos hacia atras el tamaño de char "8" porque aunque 8 bits, son ocho digitos "01",
        //un byte, un char son "8" osea que 8 representa uno que es un simbolo digamos 0 o 1, al
        //al ser un char donde esta almacenado y no se esta accediendo a los "bit puros realmente".

        //se envia un length de 8, que simulan los 8 bits, pero realmente al ser caracteres no son
        //1 byte sino 8 * 1.

        for(a = 0; a < length; ++a, --binario){

            if(*binario == '1'){
                decimal += peso;
            }

            //
            peso *= 2;
        }

        return decimal;
    }
';

            //azucar para lo anterior
            byte[8] = '
Binario                     Decimal

01010101                  =  X?

1 peso                * 1 = 1 (es uno con lo que se suma) 
2 (doblamos peso)     * 0 = 0 (no es uno con lo que no se suma)
4 (doblamos)          * 1 = 4 (es uno con lo que se suma)
8 (doblamos)          * 0 = 0 (no es uno con lo que no se suma)
16(doblamos anterior) * 1 = 16(es uno con lo que se suma)
32 ...                * 0 = 0 (no es uno con lo que no se suma)
64 ...                * 1 = 64(es uno con lo que se suma)
128 ...               * 0 = 0 (no es uno con lo que no se suma)

resultado = 1 + 4 + 16 + 64 = 85
';

            //lo que nos retorna lo añadimos y asi hasta leer enviar toda la informacion
            *text ++ = binarioToDecimal(byte, 8);
        }

        //text -= sim;
    }
';

        //lo que nos retorna lo añadimos y asi hasta leer enviar toda la informacion
        *text ++ = binarioToDecimal(byte, 8);
    }

    //text -= sim;
}

int main(void)
{
    //Test contiene la informacion.
    char informacion[] = "010000100110100101100101011011100111011001100101011011100110100101100100011011110010000001100001001000000101001101110100011000010110001101101011010011110111011001100101011100100110011001101100011011110111011100101110";

    //Se usara para mostrar la informacion
    char *textDeco;

    int informacionLength, sim;

    //usamos strlen
    informacionLength = strlen(informacion);

    /*
    para codificar cualquier caracter ASCII en binario, 
    necesitamos al menos 7 bits, en la practica se añade 
    un octavo bit y se utiliza como bit de paridad para detectar errores
    de transmision. 
    Sin embargo, estos 8 bits (1 byte) también permiten representar un 
    mayor rango de caracteres ver ASCII extendido
    */

    //basandonos en lo anterior hacemos estas matematicas, puesto que cada simbolo "consta"
    //de 8 (digamos un octeto) operamos y mas uno para la terminacion. 
    sim = informacionLength / 8 + 1;

    //malloc
    textDeco = malloc(sim + 1);

    binarioToText(informacion, informacionLength, sim, textDeco);

    printf("La informacion contenida en ASCII: %s\n", textDeco);

    //free
    free(textDeco);

    return 0;
}

To try to explain better the previous function:

Starting from the fact that the digit on the far right has a weight of 1.     because 2 ^ 0 = 1.     then if the value of the digit is 1 , it is added to the result, now the next one to the     left has the double the weight of the previous one and did to go through all, let's say the simulation     of the octet , take into account that it only adds up if, the digit is 1 , but each displacement is     double the value of the weight     on the left.

Maybe with an example you can better understand what I mean above:

#include <stdio.h>
#include <string.h>

unsigned long binarioToDecimal(char *binario, int length){

        int a;

        unsigned long decimal = 0;
        unsigned long peso = 1;

        binario += length - 1;
        peso = 1;

        //Vamos a recorrer el for tantas veces como indique length,
        //nada nuevo, pero tener encuenta que binario decrece,
        //el numero de bytes de su tipo de datos

        //saltamos hacia atras el tamaño de char "8" porque aunque 8 bits, son ocho digitos "01",
        //un byte, un char son "8" osea que 8 representa uno que es un simbolo digamos 0 o 1, al
        //al ser un char donde esta almacenado y no se esta accediendo a los bit puros realmente.

        //se envia un length de 8, que simulan los 8 bits, pero realmente al ser caracteres no son
        //1 byte sino 8 * 1.

        for(a = 0; a < length; ++a, --binario){

            if(*binario == '1'){
                decimal += peso;
            }

            //
            peso *= 2;
        }

        return decimal;
    }

    void binarioToText(char *informacionBin, int informacionLength, int sim, char *text ){

    int a;

    for(a = 0; a < informacionLength; a += 8, informacionBin += 8){

        char *byte = informacionBin;

        //Arimetica de punteros
        //*(byte+8) = '%pre%';

        //azucar para lo anterior
        byte[8] = '%pre%';

        //lo que nos retorna lo añadimos y asi hasta leer enviar toda la informacion
        *text ++ = binarioToDecimal(byte, 8);
    }

    //text -= sim;
}

int main(void)
{
    //Test contiene la informacion.
    char informacion[] = "010000100110100101100101011011100111011001100101011011100110100101100100011011110010000001100001001000000101001101110100011000010110001101101011010011110111011001100101011100100110011001101100011011110111011100101110";

    //Se usara para mostrar la informacion
    char *textDeco;

    int informacionLength, sim;

    //usamos strlen
    informacionLength = strlen(informacion);

    /*
    para codificar cualquier caracter ASCII en binario, 
    necesitamos al menos 7 bits, en la practica se añade 
    un octavo bit y se utiliza como bit de paridad para detectar errores
    de transmision. 
    Sin embargo, estos 8 bits (1 byte) también permiten representar un 
    mayor rango de caracteres ver ASCII extendido
    */

    //basandonos en lo anterior hacemos estas matematicas, puesto que cada simbolo "consta"
    //de 8 (digamos un octeto) operamos y mas uno para la terminacion. 
    sim = informacionLength / 8 + 1;

    //malloc
    textDeco = malloc(sim + 1);

    binarioToText(informacion, informacionLength, sim, textDeco);

    printf("La informacion contenida en ASCII: %s\n", textDeco);

    //free
    free(textDeco);

    return 0;
}

ideoneTest