Global Var

real UpdatePID (SPid *pid, real SP, real PV, unsigned int AUTO,real Uman) reentrant {

        real P,I,D,v,u,Es,error;

        if (AUTO){

                error = SP - PV;

                P = pid->Kp*error;
                if (pid->Ti){
                        I = pid->iState*(pid->Kp*(pid->Ts/pid->Ti)+ pid->Kwindup);
                        pid->iState = pid->iState + error;
                }else I=0;
                if (pid->Td){
                        D = (pid->Kp*(pid->Td/pid->Ts)*(PV - pid->dState));
                        pid->dState = PV;
                }else D=0;
                v = P + I + D;
                if (v > pid->uMax) u=pid->uMax;                           /* Antireset windup */
                else if (v < pid->uMin) u=pid->uMin;
                else u=v;
                Es = u-v;
                pid->Kwindup = Es/pid->Tt;

        }else{                 /* Modo Manual */

                u = Uman;
                pid->iState = Uman - (pid->Kp*error);       /* Bumpless transfer */

        }

        return u;

}

real UpdatePID (SPid *pid, real SP, real PV, unsigned int AUTO,real Uman) reentrant {

        real P,I,D,v,u,Es,error;

        if (AUTO){

                error = SP - PV;

                P = pid->Kp*error;
                if (pid->Ti){
                        I = pid->iState*(pid->Kp*(pid->Ts/pid->Ti)+ pid->Kwindup);
                        pid->iState = pid->iState + error;
                }else I=0;
                if (pid->Td){
                        D = (pid->Kp*(pid->Td/pid->Ts)*(PV - pid->dState));
                        pid->dState = PV;
                }else D=0;
                v = P + I + D;
                if (v > pid->uMax) u=pid->uMax;                           /* Antireset windup */
                else if (v < pid->uMin) u=pid->uMin;
                else u=v;
                Es = u-v;
                pid->Kwindup = Es/pid->Tt;

        }else{                 /* Modo Manual */

                u = Uman;
                pid->iState = Uman - (pid->Kp*error);       /* Bumpless transfer */

        }

        return u;

}

are you sure your gains are not 0?
if your

iA

is not updates, maybe

if (pid->Ti)

and

if (pid->Td)

are 0?
did you try to debug this code?

it is OK because if i do it:

return pid->iState;

First the value is for example 10, after is 4, but should be 14.

but you said that your iA variable is not updated! so it is updated after all, and the problem seems to be a calculation bug of some kind. I suggest you start debugging.

Always Im debugging my code, i trying everythings and im seeing for webs and datasheet.
And i dont know where is the problem. Im exasperate!!!

Thanks.

I see some serious problems with your implementation.
I think your integrator is totally wrong - you do not even accumulate the error!
it should be something like this:

double UpdatePID(SPid * pid, double error, double position)
{
  double pTerm, dTerm, iTerm;

  pTerm = pid->pGain * error;

  // calculate the proportional term
  // calculate the integral state with limiting

  pid->iState += error;
  if (pid->iState > pid->iMax) pid->iState = pid->iMax;
  else if (pid->iState < pid->iMin)
  {
     pid->iState = pid->iMin;
     iTerm = pid->iGain * iState;
  }

  dTerm = pid->dGain * (position - pid->dState);
  pid->dState = position;

  return pTerm + iTerm - dTerm;
}

If your "real" is "(signed) int" I'm in doubt if you thought about scaling, underflow and overflow of our variables.

sorry, you do accumulate the error but I still think your implementation is not correct.

Thanks for your reply.
But i think that the problem is not the implementation because is a simple acumulate.
I dont understand why this var not acumulate the old value.

The var values in my debugging are 10, 4 ,... im trying change the data type for unisgned int and is the same.

Let me give you simple example with signed int (-32768 to +32767).
In mathematical notation:

SP=3000 (setpint)
PV=0 (value read from ADC)
Kp=12
P=KP*(SP-PV)=12*(3000-0)=36000

This causes an overflow. The result is treated as a negative number.

I understand your example.
But in my code i have this:

First iteraction
SP=10 (setpint)
PV=0 (value read from ADC)
Kp=1
P=KP*(SP-PV)=1*(10-0)=10

Second iteraction
SP=10 (setpint)
PV=6 (value read from ADC)
Kp=1
P=KP*(SP-PV)=1*(10-6)=4

but my pid->iState should be 10+4=14, and it is 4

i dont know why dont save the old value in pid->iState

Are There Anybody that help me with my project??
Maybe i can send the code for see it!!!

It is very important for me!!
Thanks

You've checked only this part of your code?
You have to ensure, that there is no underflow/overflow/division by 0 in the whole code and under all circumstances (for example extreme user input).
The "updating problem":
It helps a lot if you screw down your code to the interesting core and debug it. If this fails you can show this very short program and all the necessary information to the forum.
And don't forget to mention the controller, hardware, RTX. Check the datasheet of the controller and the camera. It seems you didn't.

Sorry. "Camera" belongs to an other thread I read in parallel.

OK!
Im working with an emulator (EPM900) and an evaluation board (MCB900), my micro is Philips P89LPC936, under RTX-51.

Independent of my PID, the problem is the var update.
For example:

void Write (void) _task_ WRITE _priority_ 1 {
        int Ub=0;
        while (1){
              Ub+=1;
              TXRX_putByte(Ub); //send to serial port
        }
void main (void){
        os_start_system (WRITE);

}

The var Ub always is 1, never update the value
???????