Subversion Repositories HomeAutomation

Rev

Rev 1178 | Rev 1379 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | SVN | RSS feed

Rev 1178 Rev 1366
Line 21... Line 21...
21 
struct eeprom_act_PID EEMEM eeprom_act_PID =
 21 
struct eeprom_act_PID EEMEM eeprom_act_PID =
22 
{
 22 
{
23 
    {
 23 
    {
24 
        ///TODO: Define initialization values on the EEPROM variables here, this will generate a *.eep file that can be used to store this values to the node, can in future be done with a EEPROM module and the make-scrips. Write the values in the exact same order as the struct is defined in the *.h file.
24 
        ///TODO: Define initialization values on the EEPROM variables here, this will generate a *.eep file that can be used to store this values to the node, can in future be done with a EEPROM module and the make-scrips. Write the values in the exact same order as the struct is defined in the *.h file.
25 
        0x0200, // referenceValue
 25 
        0x0200, // referenceValue
26 
        0x00,   //SensorModuleType
 26 
        CAN_MODULE_TYPE_SNS_DS18X20,    //SensorModuleType
27 
        0x00,   //SensorModuleId
 27 
        0x00,   //SensorModuleId
28 
        0x00    //SensorId
 28 
        0x00,   //SensorId
- 
 
 29 
        0x0000, //uint16_t K_P;
- 
 
 30 
        0x0000, //uint16_t K_I;
- 
 
 31 
        0x0000, //uint16_t K_D;
- 
 
 32 
        0x00,   //uint8_t TimeMsOrS;
- 
 
 33 
        0x0000, //uint16_t Time;
- 
 
 34 
        CAN_MODULE_TYPE_ACT_SOFTPWM,    //ActuatorModuleType
- 
 
 35 
        0x00,   //ActuatorModuleId
- 
 
 36 
        0x00,   //ActuatorId
- 
 
 37 
        10, //SendPeriod
- 
 
 38 
 
29 
    },
 39 
    },
30 
    0   // crc, must be a correct value, but this will also be handled by the EEPROM module or make scripts
 40 
    0   // crc, must be a correct value, but this will also be handled by the EEPROM module or make scripts
31 
};
 41 
};
32 
 
 42 
 
33 
void calculatePID(void) {
 43 
void calculatePID(void) {
34 
    if (PID_Status == PID_OFF){
 44 
    if (PID_Status == PID_OFF){
35 
        ;// use current PWMvalue
 45 
        ;// use current PWMvalue
36 
    } else {
 46 
    } else {
37 
        pwmValue += (int16_t) pid_Controller(referenceValue, measurementValue, &pidData, &pidDebugData);
 47 
        pwmValue += (int16_t) pid_Controller(referenceValue, measurementValue, &pidData, &pidDebugData);
38 
       
 - 
 
- 
 
 48 
        printf("InOut: ref: %d, meas: %d\n",(int16_t) (referenceValue*10), (int16_t) (measurementValue*10));
39 
        if (pwmValue < MIN_PWM_VALUE) {
 49 
        if (pwmValue < MIN_PWM_VALUE) {
40 
            pwmValue = MIN_PWM_VALUE;
 50 
            pwmValue = MIN_PWM_VALUE;
41 
        }
 51 
        }
42 
        else if (pwmValue > MAX_PWM_VALUE) {
 52 
        else if (pwmValue > MAX_PWM_VALUE) {
43 
            pwmValue = MAX_PWM_VALUE-1;
 53 
            pwmValue = MAX_PWM_VALUE-1;
44 
        }
 54 
        }
45 
        //send current PWM value as soon as possible
 55 
        //send current PWM value as soon as possible
46 
        sendPID_flag=1;
 56 
        sendPID_flag=1;
47 
    }
 57 
    }
- 
 
 58 
printf("PWM: %d\n",pwmValue);
48 
}
 59 
}
49 
 
 60 
 
50 
 
 61 
 
51 
void calculatePID_callback(uint8_t timer)
 62 
void calculatePID_callback(uint8_t timer)
52 
{
 63 
{
- 
 
 64 
 
53 
    #ifdef PID_CALC_PERIOD_SECONDS
 65 
    if (eeprom_read_byte(EEDATA.TimeMsOrS) == CAN_MODULE_ENUM_PID_CONFIG_PARAMETER_TIMEUNIT_SECONDS) {
54 
    static uint8_t seconds = 0;
 66 
        static uint8_t seconds = 0;
55 
    seconds++;
 67 
        seconds++;
56 
    if (seconds >= PID_CALC_PERIOD_SECONDS)
 68 
        if (seconds >= eeprom_read_word(EEDATA16.Time))
57 
    {
 69 
        {
58 
      seconds = 0;
 70 
            seconds = 0;
59 
      calculatePID_flag = 1;
 71 
            calculatePID_flag = 1;
60 
    }
 72 
        }
61 
    #else
 73 
    } else {
62 
    calculatePID_flag = 1;
 74 
        calculatePID_flag = 1;
63 
    #endif
 75 
    }
64 
}
 76 
}
65 
 
 77 
 
66 
void sendPID(void)
 78 
void sendPID(void)
67 
{
 79 
{
- 
 
 80 
    if (eeprom_read_byte(EEDATA.actuatorModuleType) != 0) {
68 
    StdCan_Msg_t txMsg;
 81 
        StdCan_Msg_t txMsg;
69 
    StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT); ///TODO: Change this to the actual class type
 82 
        StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT); ///TODO: Change this to the actual class type
70 
    StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
 83 
        StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_TO_OWNER);
71 
    txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_PID; ///TODO: Change this to the actual module type
 84 
        txMsg.Header.ModuleType = eeprom_read_byte(EEDATA.actuatorModuleType); ///TODO: Change this to the actual module type
72 
    txMsg.Header.ModuleId = act_PID_ID;
 85 
        txMsg.Header.ModuleId = eeprom_read_byte(EEDATA.actuatorModuleId);
73 
    txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_PWM;
 86 
        txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_PWM;
74 
    txMsg.Length = 3;
 87 
        txMsg.Length = 3;
75 
    txMsg.Data[0] = PWM_ID;
 88 
        txMsg.Data[0] = eeprom_read_byte(EEDATA.actuatorId);
- 
 
 89 
        int16_t tempPWM =(int16_t) (((int32_t)pwmValue)*64/100);
76 
    txMsg.Data[1] = ((int16_t) (pwmValue)>>8)&0xff;
 90 
        txMsg.Data[1] = ( (tempPWM)>>8)&0xff;
77 
    txMsg.Data[2] = ((int16_t) (pwmValue))&0xff;
 91 
        txMsg.Data[2] = ( (tempPWM))&0xff;
- 
 
 92 
        while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
78 
   
 93 
    }
79 
    StdCan_Put(&txMsg);
 94 
    StdCan_Msg_t txMsg;
- 
 
 95 
    StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT); ///TODO: Change this to the actual class type
- 
 
 96 
    StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
- 
 
 97 
    txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_PID; ///TODO: Change this to the actual module type
- 
 
 98 
    txMsg.Header.ModuleId = act_PID_ID;
- 
 
 99 
    txMsg.Header.Command = CAN_MODULE_CMD_PID_PID_STATUS;
- 
 
 100 
    txMsg.Length = 8;
- 
 
 101 
    txMsg.Data[0] = (uint8_t)0x00ff & (((uint32_t)(measurementValue*64))>>8);
- 
 
 102 
    txMsg.Data[1] = (uint8_t)0x00ff & ((uint32_t)measurementValue*64);
- 
 
 103 
    txMsg.Data[2] = (uint8_t)0x00ff & (((uint32_t)(referenceValue*64))>>8);
- 
 
 104 
    txMsg.Data[3] = (uint8_t)0x00ff & ((uint32_t)referenceValue*64);
- 
 
 105 
    int16_t tempPWM =(int16_t) (((int32_t)pwmValue)*64/100);
- 
 
 106 
    txMsg.Data[4] = ( (tempPWM)>>8)&0xff;
- 
 
 107 
    txMsg.Data[5] = ( (tempPWM))&0xff;
- 
 
 108 
    txMsg.Data[6] = ((int16_t) (pidDebugData.Sum)>>8)&0xff;
- 
 
 109 
    txMsg.Data[7] = ((int16_t) (pidDebugData.Sum))&0xff;
- 
 
 110 
    while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
80 
}
 111 
}
81 
 
 112 
 
82 
void sendPID_callback(uint8_t timer) {
 113 
void sendPID_callback(uint8_t timer) {
83 
  sendPID_flag=1;
 114 
  sendPID_flag=1;
84 
}
 115 
}
Line 100... Line 131...
100 
    txMsg.Data[3] = ((int16_t) (pidDebugData.I_term))&0xff;
 131 
    txMsg.Data[3] = ((int16_t) (pidDebugData.I_term))&0xff;
101 
    txMsg.Data[4] = ((int16_t) (pidDebugData.D_term)>>8)&0xff;
 132 
    txMsg.Data[4] = ((int16_t) (pidDebugData.D_term)>>8)&0xff;
102 
    txMsg.Data[5] = ((int16_t) (pidDebugData.D_term))&0xff;
 133 
    txMsg.Data[5] = ((int16_t) (pidDebugData.D_term))&0xff;
103 
    txMsg.Data[6] = ((int16_t) (pidDebugData.Sum)>>8)&0xff;
 134 
    txMsg.Data[6] = ((int16_t) (pidDebugData.Sum)>>8)&0xff;
104 
    txMsg.Data[7] = ((int16_t) (pidDebugData.Sum))&0xff;
 135 
    txMsg.Data[7] = ((int16_t) (pidDebugData.Sum))&0xff;
105 
    StdCan_Put(&txMsg);
 136 
    while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
- 
 
 137 
    printf("PID: P:%d, I:%d, D:%d, S:%d\n",(int16_t)pidDebugData.P_term,(int16_t)pidDebugData.I_term,(int16_t)pidDebugData.D_term,(int16_t)pidDebugData.Sum);
106 
}
 138 
}
107 
#endif
 139 
#endif
108 
 
 140 
 
109 
void act_PID_Init(void)
 141 
void act_PID_Init(void)
110 
{
 142 
{
111 
    if (EEDATA_OK)
 143 
    if (EEDATA_OK)
112 
    {
 144 
    {
113 
    } else
 145 
    } else
114 
    {   //The CRC of the EEPROM is not correct, store default values and update CRC
 146 
    {   //The CRC of the EEPROM is not correct, store default values and update CRC
115 
      eeprom_write_word_crc(EEDATA16.referenceValue, 0x0200, WITHOUT_CRC);
 147 
      eeprom_write_word_crc(EEDATA16.referenceValue, 0x0520, WITHOUT_CRC);
116 
      eeprom_write_byte_crc(EEDATA.sensorModuleType, PID_TEMPERATURE_SENSOR_MODULE_TYPE, WITHOUT_CRC);
 148 
      eeprom_write_byte_crc(EEDATA.sensorModuleType, PID_TEMPERATURE_SENSOR_MODULE_TYPE, WITHOUT_CRC);
117 
      eeprom_write_byte_crc(EEDATA.sensorModuleId, PID_TEMPERATURE_SENSOR_MODULE_ID, WITHOUT_CRC);
 149 
      eeprom_write_byte_crc(EEDATA.sensorModuleId, PID_TEMPERATURE_SENSOR_MODULE_ID, WITHOUT_CRC);
118 
      eeprom_write_byte_crc(EEDATA.sensorId, PID_TEMPERATURE_SENSOR, WITH_CRC);
 150 
      eeprom_write_byte_crc(EEDATA.sensorId, PID_TEMPERATURE_SENSOR, WITHOUT_CRC);
- 
 
 151 
      eeprom_write_word_crc(EEDATA16.K_P, (int16_t)(DEFAULT_K_P*64), WITHOUT_CRC);
- 
 
 152 
      eeprom_write_word_crc(EEDATA16.K_I, (int16_t)(DEFAULT_K_I*64), WITHOUT_CRC);
- 
 
 153 
      eeprom_write_word_crc(EEDATA16.K_D, (int16_t)(DEFAULT_K_D*64), WITHOUT_CRC);
- 
 
 154 
      eeprom_write_byte_crc(EEDATA.TimeMsOrS, DEFAULT_PID_CALC_PERIOD_UNIT, WITHOUT_CRC);
- 
 
 155 
      eeprom_write_word_crc(EEDATA16.Time, DEFAULT_PID_CALC_PERIOD, WITHOUT_CRC);
- 
 
 156 
      eeprom_write_byte_crc(EEDATA.actuatorModuleType, PID_PWM_ACTUATOR_MODULE_TYPE, WITHOUT_CRC);
- 
 
 157 
      eeprom_write_byte_crc(EEDATA.actuatorModuleId, PID_PWM_ACTUATOR_MODULE_ID, WITHOUT_CRC);
- 
 
 158 
      eeprom_write_byte_crc(EEDATA.actuatorId, PID_PWM_ACTUATOR, WITHOUT_CRC);
- 
 
 159 
      eeprom_write_byte_crc(EEDATA.sendPeriod, 10, WITH_CRC);
119 
    }
 160 
    }
120 
    referenceValue = (float) eeprom_read_word(EEDATA16.referenceValue)/64;
 161 
    referenceValue = (float) eeprom_read_word(EEDATA16.referenceValue)/64;
121 
    sensorModuleType = eeprom_read_byte(EEDATA.sensorModuleType);
 162 
    sensorModuleType = eeprom_read_byte(EEDATA.sensorModuleType);
122 
    sensorModuleId = eeprom_read_byte(EEDATA.sensorModuleId);
 163 
    sensorModuleId = eeprom_read_byte(EEDATA.sensorModuleId);
123 
    sensorId = eeprom_read_byte(EEDATA.sensorId);
 164 
    sensorId = eeprom_read_byte(EEDATA.sensorId);
124 
 
 165 
 
- 
 
 166 
 
125 
    #ifdef PID_CALC_PERIOD_SECONDS
 167 
    if (eeprom_read_byte(EEDATA.TimeMsOrS) == CAN_MODULE_ENUM_PID_CONFIG_PARAMETER_TIMEUNIT_SECONDS) {
126 
    Timer_SetTimeout(act_PID_TIMER, 1000, TimerTypeFreeRunning, &calculatePID_callback);
 168 
        Timer_SetTimeout(act_PID_TIMER, 1000, TimerTypeFreeRunning, &calculatePID_callback);
127 
    #else
 169 
    } else {
128 
    Timer_SetTimeout(act_PID_TIMER, PID_CALC_PERIOD_mSECONDS, TimerTypeFreeRunning, &calculatePID_callback);
 170 
        Timer_SetTimeout(act_PID_TIMER, eeprom_read_word(EEDATA16.Time), TimerTypeFreeRunning, &calculatePID_callback);
129 
    #endif
 171 
    }
130 
 
 172 
 
131 
    pid_Init(K_P * SCALING_FACTOR, K_I * SCALING_FACTOR , K_D * SCALING_FACTOR , &pidData);
 173 
    pid_Init((float) eeprom_read_word(EEDATA16.K_P)/64 * SCALING_FACTOR, (float) eeprom_read_word(EEDATA16.K_I)/64 * SCALING_FACTOR , (float) eeprom_read_word(EEDATA16.K_D)/64 * SCALING_FACTOR , &pidData);
132 
    pwmValue += (int16_t) pid_Controller(referenceValue, measurementValue, &pidData, &pidDebugData);
 174 
    pwmValue += (int16_t) pid_Controller(referenceValue, measurementValue, &pidData, &pidDebugData);
133 
    PID_Status = PID_ON;
 175 
    PID_Status = PID_ON;
134 
    pwmValue = DEFAULT_PWM_VALUE;
 176 
    pwmValue = DEFAULT_PWM_VALUE;
135 
    Timer_SetTimeout(act_PID_SEND_TIMER, PID_SEND_PERIOD, TimerTypeFreeRunning, &sendPID_callback);
 177 
    Timer_SetTimeout(act_PID_SEND_TIMER, eeprom_read_byte(EEDATA.sendPeriod)*1000, TimerTypeFreeRunning, &sendPID_callback);
136 
    #ifdef act_PID_SEND_DEBUG_TIMER
 178 
    #ifdef act_PID_SEND_DEBUG_TIMER
137 
      Timer_SetTimeout(act_PID_SEND_DEBUG_TIMER, PID_SEND_DEBUG_PERIOD, TimerTypeFreeRunning, &sendPID_debug_callback);
 179 
      Timer_SetTimeout(act_PID_SEND_DEBUG_TIMER, PID_SEND_DEBUG_PERIOD, TimerTypeFreeRunning, &sendPID_debug_callback);
138 
    #endif
 180 
    #endif
139 
}
 181 
}
140 
 
 182 
 
Line 144... Line 186...
144 
        calculatePID();
 186 
        calculatePID();
145 
        calculatePID_flag = 0;
 187 
        calculatePID_flag = 0;
146 
    }
 188 
    }
147 
    if (sendPID_flag) {
 189 
    if (sendPID_flag) {
148 
        sendPID();
 190 
        sendPID();
- 
 
 191 
        sendPID_flag= 0;
149 
    }
 192 
    }
150 
}
 193 
}
151 
 
 194 
 
152 
void act_PID_HandleMessage(StdCan_Msg_t *rxMsg)
 195 
void act_PID_HandleMessage(StdCan_Msg_t *rxMsg)
153 
{
 196 
{
Line 177... Line 220...
177 
                    }
 220 
                    }
178 
                } else
 221 
                } else
179 
                {
 222 
                {
180 
                    rxMsg->Data[1] = (uint8_t)0x00ff & (((uint32_t)(referenceValue*64))>>8);
 223 
                    rxMsg->Data[1] = (uint8_t)0x00ff & (((uint32_t)(referenceValue*64))>>8);
181 
                    rxMsg->Data[2] = (uint8_t)0x00ff & ((uint32_t)referenceValue*64);
 224 
                    rxMsg->Data[2] = (uint8_t)0x00ff & ((uint32_t)referenceValue*64);
182 
                    StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
 225 
                    StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
183 
                    rxMsg->Length = 3;
 226 
                    rxMsg->Length = 3;
184 
                    while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
 227 
                    while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
185 
                }
 228 
                }
186 
 
 229 
 
187 
            }
 230 
            }
188 
        break;
 231 
        break;
189 
        case CAN_MODULE_CMD_PID_CONFIG:
 232 
        case CAN_MODULE_CMD_PID_CONFIG_SENSOR:
190 
            if (rxMsg->Length == 3)
 233 
            if (rxMsg->Length == 3)
191 
            {
 234 
            {
192 
                eeprom_write_byte_crc(EEDATA.sensorModuleType, rxMsg->Data[0] , WITHOUT_CRC);
 235 
                eeprom_write_byte_crc(EEDATA.sensorModuleType, rxMsg->Data[0] , WITHOUT_CRC);
193 
                eeprom_write_byte_crc(EEDATA.sensorModuleId, rxMsg->Data[1] , WITHOUT_CRC);
 236 
                eeprom_write_byte_crc(EEDATA.sensorModuleId, rxMsg->Data[1] , WITHOUT_CRC);
194 
                eeprom_write_byte_crc(EEDATA.sensorId, rxMsg->Data[2] , WITH_CRC);
 237 
                eeprom_write_byte_crc(EEDATA.sensorId, rxMsg->Data[2] , WITH_CRC);
195 
                sensorModuleType = eeprom_read_byte(EEDATA.sensorModuleType);
 238 
                sensorModuleType = eeprom_read_byte(EEDATA.sensorModuleType);
196 
                sensorModuleId = eeprom_read_byte(EEDATA.sensorModuleId);
 239 
                sensorModuleId = eeprom_read_byte(EEDATA.sensorModuleId);
197 
                sensorId = eeprom_read_byte(EEDATA.sensorId);
 240 
                sensorId = eeprom_read_byte(EEDATA.sensorId);
198 
            } else
 - 
 
199 
            {
 241 
            }
200 
                rxMsg->Data[0] = eeprom_read_byte(EEDATA.sensorModuleType);
 242 
            rxMsg->Data[0] = eeprom_read_byte(EEDATA.sensorModuleType);
201 
                rxMsg->Data[1] = eeprom_read_byte(EEDATA.sensorModuleId);
 243 
            rxMsg->Data[1] = eeprom_read_byte(EEDATA.sensorModuleId);
202 
                rxMsg->Data[2] = eeprom_read_byte(EEDATA.sensorId);
 244 
            rxMsg->Data[2] = eeprom_read_byte(EEDATA.sensorId);
203 
                StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
 245 
            StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
204 
                rxMsg->Length = 3;
 246 
            rxMsg->Length = 3;
- 
 
 247 
            while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
- 
 
 248 
        break;
- 
 
 249 
        case CAN_MODULE_CMD_PID_CONFIG_ACTUATOR:
- 
 
 250 
            if (rxMsg->Length == 3)
- 
 
 251 
            {
- 
 
 252 
                eeprom_write_byte_crc(EEDATA.actuatorModuleType, rxMsg->Data[0] , WITHOUT_CRC);
- 
 
 253 
                eeprom_write_byte_crc(EEDATA.actuatorModuleId, rxMsg->Data[1] , WITHOUT_CRC);
- 
 
 254 
                eeprom_write_byte_crc(EEDATA.actuatorId, rxMsg->Data[2] , WITH_CRC);
- 
 
 255 
            }
- 
 
 256 
            rxMsg->Data[0] = eeprom_read_byte(EEDATA.actuatorModuleType);
- 
 
 257 
            rxMsg->Data[1] = eeprom_read_byte(EEDATA.actuatorModuleId);
- 
 
 258 
            rxMsg->Data[2] = eeprom_read_byte(EEDATA.actuatorId);
- 
 
 259 
            StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
- 
 
 260 
            rxMsg->Length = 3;
- 
 
 261 
            while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
- 
 
 262 
        break;
- 
 
 263 
        case CAN_MODULE_CMD_GLOBAL_REPORT_INTERVAL:
- 
 
 264 
            if (rxMsg->Length == 1) {
- 
 
 265 
                if (65 <= rxMsg->Data[0])
- 
 
 266 
                    rxMsg->Data[0]=65;
- 
 
 267 
                if (0 == rxMsg->Data[0])
- 
 
 268 
                    rxMsg->Data[0]=1;
- 
 
 269 
                eeprom_write_byte_crc(EEDATA.sendPeriod, rxMsg->Data[0], WITH_CRC);
- 
 
 270 
                Timer_SetTimeout(act_PID_SEND_TIMER, rxMsg->Data[0]*1000, TimerTypeFreeRunning, &sendPID_callback);
- 
 
 271 
                StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
- 
 
 272 
                while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
- 
 
 273 
            }
- 
 
 274 
        break;
- 
 
 275 
 
- 
 
 276 
        case CAN_MODULE_CMD_PID_CONFIG_PARAMETER:
- 
 
 277 
            if (rxMsg->Length == 8)
- 
 
 278 
            {
- 
 
 279 
                eeprom_write_word_crc(EEDATA16.K_P, rxMsg->Data[1]+(rxMsg->Data[0]<<8), WITHOUT_CRC);
- 
 
 280 
                eeprom_write_word_crc(EEDATA16.K_I, rxMsg->Data[3]+(rxMsg->Data[2]<<8), WITHOUT_CRC);
- 
 
 281 
                eeprom_write_word_crc(EEDATA16.K_D, rxMsg->Data[5]+(rxMsg->Data[4]<<8), WITHOUT_CRC);
- 
 
 282 
                eeprom_write_byte_crc(EEDATA.TimeMsOrS, ((rxMsg->Data[6]&0x80)>>7), WITHOUT_CRC);
- 
 
 283 
                eeprom_write_word_crc(EEDATA16.Time, rxMsg->Data[7]+((rxMsg->Data[6]&0x7f)<<8), WITH_CRC);
- 
 
 284 
                if (eeprom_read_byte(EEDATA.TimeMsOrS) == 0) {
- 
 
 285 
                    Timer_SetTimeout(act_PID_TIMER, 1000, TimerTypeFreeRunning, &calculatePID_callback);
- 
 
 286 
                } else {
- 
 
 287 
                    Timer_SetTimeout(act_PID_TIMER, eeprom_read_word(EEDATA16.Time), TimerTypeFreeRunning, &calculatePID_callback);
- 
 
 288 
                }
- 
 
 289 
 
- 
 
 290 
                pid_Init((float) eeprom_read_word(EEDATA16.K_P)/64 * SCALING_FACTOR, (float) eeprom_read_word(EEDATA16.K_I)/64 * SCALING_FACTOR , (float) eeprom_read_word(EEDATA16.K_D)/64 * SCALING_FACTOR , &pidData);
- 
 
 291 
                pwmValue += (int16_t) pid_Controller(referenceValue, measurementValue, &pidData, &pidDebugData);
- 
 
 292 
                PID_Status = PID_ON;
- 
 
 293 
                pwmValue = DEFAULT_PWM_VALUE;
- 
 
 294 
            } else
- 
 
 295 
            {
- 
 
 296 
                rxMsg->Data[0] = (0xff00&(eeprom_read_word(EEDATA16.K_P))>>8);
- 
 
 297 
                rxMsg->Data[1] = (0x00ff&(eeprom_read_word(EEDATA16.K_P)));
- 
 
 298 
                rxMsg->Data[2] = (0xff00&(eeprom_read_word(EEDATA16.K_I))>>8);
- 
 
 299 
                rxMsg->Data[3] = (0x00ff&(eeprom_read_word(EEDATA16.K_I)));
- 
 
 300 
                rxMsg->Data[4] = (0xff00&(eeprom_read_word(EEDATA16.K_D))>>8);
- 
 
 301 
                rxMsg->Data[5] = (0x00ff&(eeprom_read_word(EEDATA16.K_D)));
- 
 
 302 
                rxMsg->Data[6] = (0xff00&(eeprom_read_word(EEDATA16.Time))>>8);
- 
 
 303 
                rxMsg->Data[7] = (0x00ff&(eeprom_read_word(EEDATA16.Time)));
- 
 
 304 
                rxMsg->Data[6] |= (0x80&(eeprom_read_byte(EEDATA.TimeMsOrS))<<7);
- 
 
 305 
                StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
- 
 
 306 
                rxMsg->Length = 8;
205 
                while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
 307 
                while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
206 
            }
 308 
            }
207 
        break;
 309 
        break;
208 
        }
 310 
        }
209 
    }
 311 
    }
Line 220... Line 322...
220 
            {
 322 
            {
221 
                //Error on the temperature signal, do something
 323 
                //Error on the temperature signal, do something
222 
            }
 324 
            }
223 
            else
 325 
            else
224 
            {
 326 
            {
225 
                measurementValue = ((rxMsg->Data[1]<<8) + rxMsg->Data[2])/64;
 327 
                measurementValue = ((float)((rxMsg->Data[1]<<8) + rxMsg->Data[2]))/64;
226 
            }
 328 
            }
227 
 
 329 
 
228 
        }
 330 
        }
229 
 
 331 
 
230 
}
 332 
}