Algumas correções relativas ao intervalo de execução do programa.

Usei um comando sleep que eu não sei se funciona no NXT. A idéia desse comando é fazer o programa ser executado a cada Ts milissegundos, o sleep ou outro comando de retardo (delay, wait, ...) não é o ideal, pois o ciclo de execução equivale ao sleep(Ts)+Ti, onde Ti é o tempo de execução das instruções. O Ti varia de acordo com as instruções e cálculos executados, fazendo com que Ts+Ti possua um certo jitter, se Ts>>Ti é aceitável. O ideal seria se o programa tivesse um comando de escalonamento temporal com baixíssimo jitter.

float kp,ki,kd,integral,derivada;
#define imax 100
#define imin 0
#define val 50
const float Ts=100;
int offset,luz,erro,pa,pc,max=0,min=9999,contador,ultimoerro=0;
void calibracao(int &ma, int &min)
{
     int aux;
     OnRev(OUT_C, 25);
     OnFwd(OUT_A, 25);
     do
     {
       aux=Sensor(IN_1);
       if(aux<min) min=aux;
       if(aux>max) max=aux;
     }
     while(MotorRotationCount(OUT_A)<=120);
}
task main()
{
     float ti,pid;
     SetSensor(IN_1, SENSOR_COLORRED);
     SetSensorMode(IN_1, IN_MODE_PCTFULLSCAL E);
     calibracao(max, min);
     offset=(max+min)/2;
     OnRev(OUT_C, 25);
     OnFwd(OUT_A, 25);
     while(true)
     {
           luz=Sensor(IN_1);
           if((luz>max+5||luz<min-5)&&contador==1)
           {
                OnFwd(OUT_C, 70);
                OnRev(OUT_A, 30);
                contador=0;
           }
           else if((luz>max+5||luz<min-5)&&contador==0) Off(OUT_AC);
           erro=luz-offset;
           integral+=erro;
           if(integral>imax) integral=imax;
           if(integral<imin) integral=imin;
           derivada=erro-ultimoerro;
           pid=kp*erro+ki*integral*Ts+kd*derivada/Ts;
           pa=val-pid;
           pc=val+pid;
           OnFwd(OUT_A, pa);
           if(pc>0) OnFwd(OUT_C, pc);
           else
           {
               pc*=(-1);
               OnRev(OUT_C, pc);
           }
           ultimoerro=erro;
           sleep( Ts );
     }
}

Se você fizer um programa de multiplicação em assembly (linguagem de máquina) vai perceber que o tempo para executar uma simples multiplicação de dois números inteiros não é fixo, mas depende do tamanho dos números, isso vale para qualquer operação feita por um computador. Desse modo, o tempo de execução de um algoritmo PID não é fixo ao operar com uma variável digitalizada do mundo real cujo valor muda pelo controle e por fatores aleatórios (perturbações, ruído, ...).

Por outro lado, ao calcular uma integral numericamente, o tempo de integração deve ser repetitivo, senão o cálculo estará errado. Isso vale também para a derivada no tempo.

Simplisticamente, tentei explicar por que Ts tem que ser fixo e maior que o tempo de execução dos cálculos, de preferência Ts não deve ser influenciado pelo tempo necessário aos cálculos. Além disso, Ts deve ser menor do que a metade do tempo de reação do processo (o dobro pelo menos - Teorema de Nyquist).
 

Quais outras formas de controle além de usar PID e On-Off?
O que são métodos heurísticos? Em Robótica qual seria a aplicabilidade?

Além do PID, há ainda os algoritmos de controle baseados em modelo (MPC - Model predictive control), que usam um modelo do processo. Os controladores baseados em modelo requerem modelos do processo, técnicas de modelagem ou uma forma alternativa de modelar sistemas (processos a serem controlados com uma ou mais entradas e uma ou mais saídas).

Para a modelagem de processo, temos as técnicas baseadas em modelos fenomenológicos (que modelam um processo a partir de uma modelagem formal física, química, etc...), porém, frequentemente, esse tipo de modelo apresenta limitações ou não consegue modelar perfeitamente um processo real em sua complexidade. Uma alternativa aos modelos fenomenológicos são as técnicas heurísiticas, que utilizam a assimilação de um comportamento obtido do processo a ser controlado, esse comportamento pode ser uma série de valores de entrada e saída obtidos, que embutem uma relação causa e efeito do processo. Esse "conhecimento" embutido nos dados pode ser asssimilado por modelos baseados em redes neurais, ou implementados num controlador fuzzy, por exemplo. Desse modo, a técnica de "apreender a realidade", ou "com a experiência", é a base das técnicas heurísticas, também conhecidas como "inteligência computacional".