Un placer 

Bien.
Mira:
Lo primero de todo, para entender lo que debes hacer es entender qué te pide la función, así que voy a desglosarla:
void: Como te he dicho indica que la función no retorna valor alguno, solo realiza un trabajo.
codigoAleatorio: Tú dices que debe generar un código aleatorio en el array que se le va a pasar. De ahí que tenga ese nombre.
tCodigo codigo: Es el array que le pasarás a esta función. Ahora algo que seguramente no has visto: Los arrays y punteros se dice que se pasan por referencia, es decir, ese dato se podrá cambiar. El funcionamiento interno es un poco más complicado, pero por ahora te basta saber eso. Así es como la función retornará el array relleno.
bool admiteRepetidos: Dato que indicará si se pueden repetir los elementos.

Como puedes ver no hay ningún argumento que diga el tamaño que tendrá el array, así que lo deberás tomar de la constante que usaste para declararlo: TAM_CODIGO.

Deduzco que la función que te ha dado el profesor es la de la librería estándar rand().

Deduzco, partiendo de lo que has ido mostrando, es que el código se realiza a partir de una combinación de las letras R, Z, V, A, M, B.

Así que empiezo a escribir:

void codigoAleatorio(tCodigo codigo, bool admiteRepetidos) {
    unsigned i; // mi índice para el array.
    unsigned j; // mi índice para un array auxiliar, ver mas abajo.
    char c; // tendrá el elemento del código seleccionado.
    char elementosCodigo[] = {'R', 'Z', 'V', 'A', 'M', 'B'}; // el array que contiene los elementos que conforman el código.
    const unsigned TAM_ELEM_COD = 6; // 6 es el tamaño del array elementosCodigo. En verdad se debería sustituir 6 por 'sizeof(elementosCodigo) / sizeof(char)', pero por razones de que todavía no habrás avanzado lo suficiente en el curso lo dejo con el 6.
 
    // Ahora voy a rellenar el array codigo que ha recibido la función.
    for(i = 0; i < TAM_CODIGO; ++i) {
        j = rand() % TAM_ELEM_COD;
        // Ahora viene la parte donde trabajamos con si se admiten elementos repetidos o no.
        if(!admiteRepetidos) { // Si no se admiten repetidos...
            // La idea es cambiar el dato de elementosCodigo que ya se ha usado a 0, así sabremos que ese ya se ha pillado.
            while((c = elementosCodigo[j]) == 0) { // Mientras encontremos que el elemento seleccionado ya ha sido escogido con anterioridad
                ++j; // Elegiremos el siguiente elemento.
                if(j >= TAM_ELEM_COD); // Si el índice j queda fuera del array de código...
                    j = 0; // Se regresa el índice al inicio.
            } // Terminado el while c tendrá un carácter válido y j estará sobre ese elemento que no se ha repetido.
            elementosCodigo[j] = 0; // Para evitar que en posteriores búsquedas, para rellenar el array codigo, se elija de nuevo esta posición, se marca con el 0.
        } // Como en el paso anterior ya tenemos un elemento del código válido podemos continuar. Nótese que si se admitieran repetidos la función es la misma, lo único que todo lo que hay dentro del if se puede omitir, por eso que se ha escrito de esta forma.
        codigo[i] = c; // Se copia a la posición i del array codigo el carácter obtenido de elementosCodigo.
    } // Terminado el for ya tenemos el código listo por tanto...
} // fin de la función.

               

¿Exactamente qué te pide exactamente?

Olvídate del void. En este caso indica que la función no devuelve ningún valor, solo hace un trabajo (en otros lenguajes se llamaría procedimiento o subprograma).

Cuando se pasa un array a una función lo normal es pasar también el número de elementos que el array contiene en otro argumento y así la función conocerá el límite. De todas formas tú usas una variación de eso qué es mediante una variable global llamada TAM_CODIGO, que por otra parte, en el primer código que has mostrado la llamas 'tamaño'.

Es decir, dentro de la función debes olvidarte del tamaño del array, lo verás como si fuera un puntero (o un entero sin signo, por si no has llegado a los punteros) y usa para trabajar con él los límites, ya sean variables globales o argumentos que lo van a acompañar en las llamadas a funciones.

Vale. El void no es lo que pasas sino el tipo de dato devuelto de la función. Por otra parte te diría que mires un paper de lo que ocurre cuando se usa un array como argumento.

A grandes rasgos un array de una dimensión es lo mismo que un puntero, solo se pasará la dirección del primer elemento, todos los demás 'adornos' como el tipo de dato del array y loas restantes dimensiones que pueda tener (se especifican todas las dimensiones de un array menos la de más a la izquierda) solo sirven para, internamente, hacer aritmética y encontrar el dato deseado cuando usas notación de array.

Por tanto un array, cuando es pasado a una función, pierde toda la información de su tamaño y, a ojos del compilador, es un puntero.

Tienes algunos fallos que atribuyó a que aunque no conoces del todo el lenguaje y buenas prácticas, pero me gustaría que explicarás en qué notas que el array cambia el tamaño.
Lo que si he observado es que haces cosas así:


TAM_CODIGO marca el número de elementos, como C empieza por el 0 el máximo índice será TAM_CODIGO -1, y precisamente ese es al que va a llegar el for con la sentencia s<TAM_CODIGO: mientras s esté por debajo de TAM_CODIGO se va a ejecutar su código asociado. Pero tú le restas 1 a TAM_CODIGO con lo que no ejecutará las veces suficientes el código asociado, te faltará una. Tal vez eso es lo que te pasa.

Una solución rápida sería prepara un array tan largo como el mayor número, en decimal, representable con la palabra de tu uC más 1:
De 8 bits es 4 (255)
De 16 bits es 6 (65535)
Etc.

Si también vas a poder representar números negativos recuerda añadir otro carácter para representar el símbolo -

Índice = 0
Si el número es negativo márcalo con una variable y haces tu número positivo: número = -número
Hasta que el número sea 0:
    Array[índice] = (número % 10) + '0' // para transformar el número en su carácter ASCII
    Número = número / 10
    Índice = índice + 1

Si tu número era negativo (observando lo que dice la variable que has marcado anteriormente) añade el carácter - a tu cadena
En cambio si era positivo resta 1 a índice.

Ahora, aprovechando que índice te marca el final de la cadena, la inviertes. A la resultante le añades el carácter '\0' detrás para cerrarla.

Ya tienes tu número transformado en cadena.

No hace falta que sean contadores diferentes, puedes seguir incrementando el mismo. También tienes isalpha que discrimina letras, pero ahora no sé si con el correspondiente locales en español también le entran acentos y eñes.

Mira si tienes sprintf, que es igual a printf pero en vez de a la salida estándar el resultado va a un buffer tipo char* o lo haces a mano con módulos, divisiones y sumas en un for.

Debe poner algo más que ese error. El problema no es el compilador, es el enlazador que no encuentra una referencia. Tal vez la biblioteca estándar no esté bien instalada y no la encuentra, o no esté configurado su path.